FastComments C++ SDK

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

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

Repository

Voraussetzungen

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

Installation

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 zwei Klassen, DefaultAPI und PublicAPI. Die DefaultAPI enthält Methoden, die Ihren API-Schlüssel benötigen, und PublicAPI enthält API-Aufrufe die direkt von einem Browser/Mobilgerät/etc. ohne Authentifizierung ausgeführt werden können.

Schnellstart

Authentifizierte APIs verwenden (DefaultAPI)

Wichtig:

Sie müssen die Basis-URL festlegen (cpp-restsdk-Generator liest sie nicht aus der OpenAPI-Spezifikation)
Sie müssen Ihren API-Schlüssel auf dem ApiClient setzen, bevor Sie authentifizierte Anfragen stellen. Wenn Sie das nicht tun, schlagen 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: Legen Sie die Basis-URL fest (wählen Sie Ihre Region)
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));  // US
    // OR: config->setBaseUrl(utility::conversions::to_string_t("https://eu.fastcomments.com"));  // EU

    // ERFORDERLICH: Legen Sie Ihren API-Schlüssel fest
    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 durchführen
    return 0;
}

Öffentliche APIs verwenden (PublicAPI)

Öffentliche Endpunkte erfordern 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: Legen Sie die Basis-URL fest
    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 durchführen
    return 0;
}

Häufige Probleme

"URI must contain a hostname" error: 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" error: 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.
Wrong API class: Verwenden Sie DefaultAPI für serverseitige authentifizierte Anfragen, PublicAPI für clientseitige/öffentliche Anfragen.

API-Aufrufe: Synchron vs. Asynchron

Alle API-Methoden in diesem SDK geben pplx::task<std::shared_ptr<ResponseType>> aus dem C++ REST SDK zurück. Das gibt Ihnen Flexibilität dabei, wie Sie API-Antworten verarbeiten.

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

// Rufen Sie .get() auf, um zu blockieren und das Ergebnis synchron zu erhalten
auto response = api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    boost::none,  // page
    boost::none,  // limit
    boost::none,  // skip
    boost::none,  // asTree
    boost::none,  // skipChildren
    boost::none,  // limitChildren
    boost::none,  // maxTreeDepth
    utility::conversions::to_string_t("your-url-id"),  // urlId
    boost::none,  // userId
    boost::none,  // anonUserId
    boost::none,  // contextUserId
    boost::none,  // hashTag
    boost::none,  // parentId
    boost::none   // direction
).get();  // Blockiert, bis die HTTP-Anfrage abgeschlossen ist

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 Rückrufen:

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

// Verwenden Sie .then() für asynchrone, callback-basierte Ausführung
api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    boost::none, boost::none, boost::none, boost::none, boost::none,
    boost::none, boost::none,
    utility::conversions::to_string_t("your-url-id"),
    boost::none, boost::none, boost::none, boost::none, boost::none, boost::none
).then([](std::shared_ptr<GetComments_200_response> response) {
    // Dies wird asynchron ausgeführt, wenn die Anfrage abgeschlossen ist
    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;

Entscheidung zwischen synchronen und asynchronen Aufrufen

Die Wahl hängt von Ihrer Laufzeitumgebung und der Architektur Ihrer Anwendung ab:

.get() (Synchrones Blockieren)

Blockiert den aufrufenden Thread, bis die HTTP-Anfrage abgeschlossen ist
Einfacherer Programmablauf, leichter nachzuvollziehen
Geeignet für dedizierte Worker-Threads, Batch-Verarbeitung oder Kommandozeilen-Tools
Nicht geeignet für Event-Loops, GUI-Threads oder Single-Thread-Server

.then() (Asynchron, nicht-blockierend)

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 single-threaded Event-Loops
Ermöglicht das Verketten mehrerer Operationen
Komplexere Steuerungsabläufe

Die Test-Suite des SDK verwendet ausschließlich .get(), was für die Testumgebung angemessen ist, in der Blockieren akzeptabel 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

Dokumentation der API-Endpunkte

Alle URIs sind relativ zu https://fastcomments.com

Klasse	Methode	HTTP-Anfrage	Beschreibung
DefaultApi	addDomainConfig	POST /api/v1/domain-configs
DefaultApi	addHashTag	POST /api/v1/hash-tags
DefaultApi	addHashTagsBulk	POST /api/v1/hash-tags/bulk
DefaultApi	addPage	POST /api/v1/pages
DefaultApi	addSSOUser	POST /api/v1/sso-users
DefaultApi	aggregate	POST /api/v1/aggregate	Aggregiert Dokumente durch Gruppieren (falls groupBy angegeben ist) und die Anwendung mehrerer Operationen. Verschiedene Operationen (z. B. sum, countDistinct, avg, usw.) werden unterstützt.
DefaultApi	aggregateQuestionResults	GET /api/v1/question-results-aggregation
DefaultApi	blockUserFromComment	POST /api/v1/comments/{id}/block
DefaultApi	bulkAggregateQuestionResults	POST /api/v1/question-results-aggregation/bulk
DefaultApi	changeTicketState	PATCH /api/v1/tickets/{id}/state
DefaultApi	combineCommentsWithQuestionResults	GET /api/v1/question-results-aggregation/combine/comments
DefaultApi	createEmailTemplate	POST /api/v1/email-templates
DefaultApi	createFeedPost	POST /api/v1/feed-posts
DefaultApi	createModerator	POST /api/v1/moderators
DefaultApi	createQuestionConfig	POST /api/v1/question-configs
DefaultApi	createQuestionResult	POST /api/v1/question-results
DefaultApi	createSubscription	POST /api/v1/subscriptions
DefaultApi	createTenant	POST /api/v1/tenants
DefaultApi	createTenantPackage	POST /api/v1/tenant-packages
DefaultApi	createTenantUser	POST /api/v1/tenant-users
DefaultApi	createTicket	POST /api/v1/tickets
DefaultApi	createUserBadge	POST /api/v1/user-badges
DefaultApi	createVote	POST /api/v1/votes
DefaultApi	deleteComment	DELETE /api/v1/comments/{id}
DefaultApi	deleteDomainConfig	DELETE /api/v1/domain-configs/{domain}
DefaultApi	deleteEmailTemplate	DELETE /api/v1/email-templates/{id}
DefaultApi	deleteEmailTemplateRenderError	DELETE /api/v1/email-templates/{id}/render-errors/{errorId}
DefaultApi	deleteHashTag	DELETE /api/v1/hash-tags/{tag}
DefaultApi	deleteModerator	DELETE /api/v1/moderators/{id}
DefaultApi	deleteNotificationCount	DELETE /api/v1/notification-count/{id}
DefaultApi	deletePage	DELETE /api/v1/pages/{id}
DefaultApi	deletePendingWebhookEvent	DELETE /api/v1/pending-webhook-events/{id}
DefaultApi	deleteQuestionConfig	DELETE /api/v1/question-configs/{id}
DefaultApi	deleteQuestionResult	DELETE /api/v1/question-results/{id}
DefaultApi	deleteSSOUser	DELETE /api/v1/sso-users/{id}
DefaultApi	deleteSubscription	DELETE /api/v1/subscriptions/{id}
DefaultApi	deleteTenant	DELETE /api/v1/tenants/{id}
DefaultApi	deleteTenantPackage	DELETE /api/v1/tenant-packages/{id}
DefaultApi	deleteTenantUser	DELETE /api/v1/tenant-users/{id}
DefaultApi	deleteUserBadge	DELETE /api/v1/user-badges/{id}
DefaultApi	deleteVote	DELETE /api/v1/votes/{id}
DefaultApi	flagComment	POST /api/v1/comments/{id}/flag
DefaultApi	getAuditLogs	GET /api/v1/audit-logs
DefaultApi	getCachedNotificationCount	GET /api/v1/notification-count/{id}
DefaultApi	getComment	GET /api/v1/comments/{id}
DefaultApi	getComments	GET /api/v1/comments
DefaultApi	getDomainConfig	GET /api/v1/domain-configs/{domain}
DefaultApi	getDomainConfigs	GET /api/v1/domain-configs
DefaultApi	getEmailTemplate	GET /api/v1/email-templates/{id}
DefaultApi	getEmailTemplateDefinitions	GET /api/v1/email-templates/definitions
DefaultApi	getEmailTemplateRenderErrors	GET /api/v1/email-templates/{id}/render-errors
DefaultApi	getEmailTemplates	GET /api/v1/email-templates
DefaultApi	getFeedPosts	GET /api/v1/feed-posts	req tenantId afterId
DefaultApi	getHashTags	GET /api/v1/hash-tags
DefaultApi	getModerator	GET /api/v1/moderators/{id}
DefaultApi	getModerators	GET /api/v1/moderators
DefaultApi	getNotificationCount	GET /api/v1/notifications/count
DefaultApi	getNotifications	GET /api/v1/notifications
DefaultApi	getPageByURLId	GET /api/v1/pages/by-url-id
DefaultApi	getPages	GET /api/v1/pages
DefaultApi	getPendingWebhookEventCount	GET /api/v1/pending-webhook-events/count
DefaultApi	getPendingWebhookEvents	GET /api/v1/pending-webhook-events
DefaultApi	getQuestionConfig	GET /api/v1/question-configs/{id}
DefaultApi	getQuestionConfigs	GET /api/v1/question-configs
DefaultApi	getQuestionResult	GET /api/v1/question-results/{id}
DefaultApi	getQuestionResults	GET /api/v1/question-results
DefaultApi	getSSOUserByEmail	GET /api/v1/sso-users/by-email/{email}
DefaultApi	getSSOUserById	GET /api/v1/sso-users/by-id/{id}
DefaultApi	getSSOUsers	GET /api/v1/sso-users
DefaultApi	getSubscriptions	GET /api/v1/subscriptions
DefaultApi	getTenant	GET /api/v1/tenants/{id}
DefaultApi	getTenantDailyUsages	GET /api/v1/tenant-daily-usage
DefaultApi	getTenantPackage	GET /api/v1/tenant-packages/{id}
DefaultApi	getTenantPackages	GET /api/v1/tenant-packages
DefaultApi	getTenantUser	GET /api/v1/tenant-users/{id}
DefaultApi	getTenantUsers	GET /api/v1/tenant-users
DefaultApi	getTenants	GET /api/v1/tenants
DefaultApi	getTicket	GET /api/v1/tickets/{id}
DefaultApi	getTickets	GET /api/v1/tickets
DefaultApi	getUser	GET /api/v1/users/{id}
DefaultApi	getUserBadge	GET /api/v1/user-badges/{id}
DefaultApi	getUserBadgeProgressById	GET /api/v1/user-badge-progress/{id}
DefaultApi	getUserBadgeProgressByUserId	GET /api/v1/user-badge-progress/user/{userId}
DefaultApi	getUserBadgeProgressList	GET /api/v1/user-badge-progress
DefaultApi	getUserBadges	GET /api/v1/user-badges
DefaultApi	getVotes	GET /api/v1/votes
DefaultApi	getVotesForUser	GET /api/v1/votes/for-user
DefaultApi	patchDomainConfig	PATCH /api/v1/domain-configs/{domainToUpdate}
DefaultApi	patchHashTag	PATCH /api/v1/hash-tags/{tag}
DefaultApi	patchPage	PATCH /api/v1/pages/{id}
DefaultApi	patchSSOUser	PATCH /api/v1/sso-users/{id}
DefaultApi	putDomainConfig	PUT /api/v1/domain-configs/{domainToUpdate}
DefaultApi	putSSOUser	PUT /api/v1/sso-users/{id}
DefaultApi	renderEmailTemplate	POST /api/v1/email-templates/render
DefaultApi	replaceTenantPackage	PUT /api/v1/tenant-packages/{id}
DefaultApi	replaceTenantUser	PUT /api/v1/tenant-users/{id}
DefaultApi	saveComment	POST /api/v1/comments
DefaultApi	saveCommentsBulk	POST /api/v1/comments/bulk
DefaultApi	sendInvite	POST /api/v1/moderators/{id}/send-invite
DefaultApi	sendLoginLink	POST /api/v1/tenant-users/{id}/send-login-link
DefaultApi	unBlockUserFromComment	POST /api/v1/comments/{id}/un-block
DefaultApi	unFlagComment	POST /api/v1/comments/{id}/un-flag
DefaultApi	updateComment	PATCH /api/v1/comments/{id}
DefaultApi	updateEmailTemplate	PATCH /api/v1/email-templates/{id}
DefaultApi	updateFeedPost	PATCH /api/v1/feed-posts/{id}
DefaultApi	updateModerator	PATCH /api/v1/moderators/{id}
DefaultApi	updateNotification	PATCH /api/v1/notifications/{id}
DefaultApi	updateQuestionConfig	PATCH /api/v1/question-configs/{id}
DefaultApi	updateQuestionResult	PATCH /api/v1/question-results/{id}
DefaultApi	updateSubscription	PATCH /api/v1/subscriptions/{id}
DefaultApi	updateTenant	PATCH /api/v1/tenants/{id}
DefaultApi	updateTenantPackage	PATCH /api/v1/tenant-packages/{id}
DefaultApi	updateTenantUser	PATCH /api/v1/tenant-users/{id}
DefaultApi	updateUserBadge	PUT /api/v1/user-badges/{id}
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	deleteCommentPublic	DELETE /comments/{tenantId}/{commentId}
PublicApi	deleteCommentVote	DELETE /comments/{tenantId}/{commentId}/vote/{voteId}
PublicApi	deleteFeedPostPublic	DELETE /feed-posts/{tenantId}/{postId}
PublicApi	flagCommentPublic	POST /flag-comment/{commentId}
PublicApi	getCommentText	GET /comments/{tenantId}/{commentId}/text
PublicApi	getCommentVoteUserNames	GET /comments/{tenantId}/{commentId}/votes
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	getGlobalEventLog	GET /event-log/global/{tenantId}	req tenantId urlId userIdWS
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	lockComment	POST /comments/{tenantId}/{commentId}/lock
PublicApi	pinComment	POST /comments/{tenantId}/{commentId}/pin
PublicApi	reactFeedPostPublic	POST /feed-posts/{tenantId}/react/{postId}
PublicApi	resetUserNotificationCount	POST /user-notifications/reset-count
PublicApi	resetUserNotifications	POST /user-notifications/reset
PublicApi	searchUsers	GET /user-search/{tenantId}
PublicApi	setCommentText	POST /comments/{tenantId}/{commentId}/update-text
PublicApi	unBlockCommentPublic	DELETE /block-from-comment/{commentId}
PublicApi	unLockComment	POST /comments/{tenantId}/{commentId}/unlock
PublicApi	unPinComment	POST /comments/{tenantId}/{commentId}/unpin
PublicApi	updateFeedPostPublic	PUT /feed-posts/{tenantId}/{postId}
PublicApi	updateUserNotificationCommentSubscriptionStatus	POST /user-notifications/{notificationId}/mark-opted/{optedInOrOut}	Benachrichtigungen für einen bestimmten Kommentar aktivieren oder deaktivieren.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Benachrichtigungen für eine Seite aktivieren oder deaktivieren. Wenn Benutzer eine Seite abonniert haben, werden Benachrichtigungen für neue Root-Kommentare erstellt, sowie auch
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Bild hochladen und skalieren
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Dokumentation der Modelle

Aggregieren

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
aggregationRequest	AggregationRequest	Ja
parentTenantId	string	Nein
includeStats	bool	Nein

Antwort

Gibt zurück: AggregationResponse

Beispiel

aggregate Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
AggregationRequest aggReq;
boost::optional<utility::string_t> parentTenant = boost::optional<utility::string_t>(U("parent-org-456"));
boost::optional<bool> includeStats = boost::optional<bool>(true);
auto aggTask = api->aggregate(tenantId, aggReq, parentTenant, includeStats)
    .then([](pplx::task<std::shared_ptr<AggregationResponse>> t) {
        try {
            auto res = t.get();
            auto out = std::make_shared<AggregationResponse>(*res);
            return out;
        } catch (...) {
            return std::shared_ptr<AggregationResponse>();
        }
    });

Audit-Protokolle abrufen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
limit	double	Nein
skip	double	Nein
order	SORT_DIR	Nein
after	double	Nein
before	double	Nein

Antwort

Gibt zurück: GetAuditLogs_200_response

Beispiel

getAuditLogs-Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> limit = 100;
boost::optional<double> skip = 0;
boost::optional<SORT_DIR> order = SORT_DIR::DESC;
boost::optional<double> after = 1633046400;
boost::optional<double> before = 1633132800;
api->getAuditLogs(tenantId, limit, skip, order, after, before)
.then([](pplx::task<std::shared_ptr<GetAuditLogs_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<GetAuditLogs_200_response>(*resp);
            (void)copy;
        }
    } catch (...) {
    }
});

Öffentlich: Vom Kommentar blockieren

Parameter

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

Antwort

Gibt zurück: BlockFromCommentPublic_200_response

Beispiel

blockFromCommentPublic Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654321");
PublicBlockFromCommentParams params;
params.reason = U("Repeated harassment");
params.durationMinutes = 1440;
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-token-abc123"));
auto placeholder = std::make_shared<BlockFromCommentPublic_200_response>();
api->blockFromCommentPublic(tenantId, commentId, params, sso)
.then([](pplx::task<std::shared_ptr<BlockFromCommentPublic_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) std::wcout << U("Comment blocked successfully\n");
        else std::wcout << U("Block request returned empty response\n");
    } catch (...) {
        std::wcout << U("Block request failed\n");
    }
});

Öffentlich: Kommentar-Blockierung aufheben

Parameter

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

Antwort

Gibt zurück: UnBlockCommentPublic_200_response

Beispiel

unBlockCommentPublic Beispiel

Copy

auto publicParams = std::make_shared<PublicBlockFromCommentParams>();
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(utility::string_t(U("user@example.com")));
api->unBlockCommentPublic(utility::string_t(U("my-tenant-123")), utility::string_t(U("comment-98765")), *publicParams, sso)
.then([](pplx::task<std::shared_ptr<UnBlockCommentPublic_200_response>> task) {
    try {
        auto resp = task.get();
        if (resp) std::cout << "Unblocked comment successfully" << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Unblock failed: " << e.what() << std::endl;
    }
});

Gesperrte Kommentare überprüfen

Parameter

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

Antwort

Gibt zurück: CheckedCommentsForBlocked_200_response

Beispiel

checkedCommentsForBlocked Beispiel

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
utility::string_t commentIds = utility::conversions::to_string_t("cmt-456,cmt-789");
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("user@example.com");
auto task = api->checkedCommentsForBlocked(tenantId, commentIds, sso)
    .then([=](std::shared_ptr<CheckedCommentsForBlocked_200_response> resp) -> std::shared_ptr<CheckedCommentsForBlocked_200_response> {
        if (!resp) return std::make_shared<CheckedCommentsForBlocked_200_response>();
        return resp;
    });

Benutzer vom Kommentar blockieren

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
blockFromCommentParams	BlockFromCommentParams	Ja
userId	string	Nein
anonUserId	string	Nein

Antwort

Gibt zurück: BlockFromCommentPublic_200_response

Beispiel

blockUserFromComment Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
auto blockParams = std::make_shared<BlockFromCommentParams>();
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<utility::string_t> anonUserId = boost::optional<utility::string_t>(U("anon-98765"));
api->blockUserFromComment(tenantId, commentId, *blockParams, userId, anonUserId)
.then([](std::shared_ptr<BlockFromCommentPublic_200_response> resp){
    if (resp) {
        std::cout << "User blocked successfully\n";
    } else {
        std::cout << "Block request returned empty response\n";
    }
}).wait();

Öffentlich: Kommentar erstellen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
urlId	string	Ja
broadcastId	string	Ja
commentData	CommentData	Ja
sessionId	string	Nein
sso	string	Nein

Antwort

Gibt zurück: CreateCommentPublic_200_response

Beispiel

createCommentPublic Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("/articles/2026/fastcomments-cpp-integration");
utility::string_t broadcastId = U("broadcast-001");
CommentData commentData;
commentData.content = U("Hello from the C++ SDK — great article!");
commentData.authorEmail = U("reader@example.com");
commentData.authorName = U("Jane Reader");
boost::optional<utility::string_t> sessionId = boost::optional<utility::string_t>(U("sess-9f3a2"));
boost::optional<utility::string_t> sso = boost::none;
auto task = api->createCommentPublic(tenantId, urlId, broadcastId, commentData, sessionId, sso)
    .then([](pplx::task<std::shared_ptr<CreateCommentPublic_200_response>> t) {
        try {
            auto resp = t.get();
            if (resp) {
                auto resultCopy = std::make_shared<CreateCommentPublic_200_response>(*resp);
            }
        } catch (const std::exception&) {}
    });
task.wait();

Kommentar löschen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
contextUserId	string	Nein
isLive	bool	Nein

Antwort

Gibt zurück: DeleteComment_200_response

Beispiel

deleteComment Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654321");
boost::optional<utility::string_t> contextUserId = boost::optional<utility::string_t>(U("moderator@acme.com"));
boost::optional<bool> isLive = boost::optional<bool>(true);
api->deleteComment(tenantId, commentId, contextUserId, isLive)
.then([](pplx::task<std::shared_ptr<DeleteComment_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto processed = std::make_shared<DeleteComment_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

Öffentlich: Kommentar löschen

Parameter

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

Antwort

Gibt zurück: DeleteCommentPublic_200_response

Beispiel

deleteCommentPublic Beispiel

Copy

utility::string_t tenantId(U("my-tenant-123"));
utility::string_t commentId(U("cmt-456"));
utility::string_t broadcastId(U("brd-789"));
boost::optional<utility::string_t> editKey = boost::optional<utility::string_t>(utility::string_t(U("editkey-abc123")));
boost::optional<utility::string_t> sso; 
api->deleteCommentPublic(tenantId, commentId, broadcastId, editKey, sso)
.then([](pplx::task<std::shared_ptr<DeleteCommentPublic_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto copied = std::make_shared<DeleteCommentPublic_200_response>(*resp);
            (void)copied;
        }
    } catch (const std::exception&) {
        auto fallback = std::make_shared<DeleteCommentPublic_200_response>();
        (void)fallback;
    }
});

Kommentarabstimmung löschen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
voteId	string	Ja
urlId	string	Ja
broadcastId	string	Ja
editKey	string	Nein
sso	string	Nein

Antwort

Gibt zurück: DeleteCommentVote_200_response

Beispiel

deleteCommentVote Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-789");
utility::string_t voteId = U("vote-456");
utility::string_t urlId = U("/articles/2026/fastcomments-guide");
utility::string_t broadcastId = U("broadcast-001");
boost::optional<utility::string_t> editKey = boost::optional<utility::string_t>(U("editkey-abc"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
auto placeholder = std::make_shared<DeleteCommentVote_200_response>();
api->deleteCommentVote(tenantId, commentId, voteId, urlId, broadcastId, editKey, sso)
.then([=](pplx::task<std::shared_ptr<DeleteCommentVote_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) std::cout << "Vote deleted\n";
    } catch (const std::exception &e) {
        std::cerr << "Delete failed: " << e.what() << '\n';
    }
});

Kommentar melden

Parameter

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

Antwort

Gibt zurück: FlagComment_200_response

Beispiel

flagComment Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
boost::optional<utility::string_t> userId{ utility::string_t(U("user@example.com")) };
boost::optional<utility::string_t> anonUserId;
api->flagComment(tenantId, commentId, userId, anonUserId)
.then([](std::shared_ptr<FlagComment_200_response> resp) {
    auto result = resp ? resp : std::make_shared<FlagComment_200_response>();
    (void)result;
});

Kommentar abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: GetComment_200_response

Beispiel

getComment Beispiel

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> maybeId = utility::conversions::to_string_t("comment-98765");
auto getTask = api->getComment(tenantId, *maybeId)
    .then([](pplx::task<std::shared_ptr<GetComment_200_response>> t) {
        try {
            auto resp = t.get();
            auto result = resp ? resp : std::make_shared<GetComment_200_response>();
            return result;
        } catch (const std::exception&) {
            return std::make_shared<GetComment_200_response>();
        }
    });

Kommentare abrufen

Parameter

Name	Type	Erforderlich
tenantId	string	Ja
page	int32_t	Nein
limit	int32_t	Nein
skip	int32_t	Nein
asTree	bool	Nein
skipChildren	int32_t	Nein
limitChildren	int32_t	Nein
maxTreeDepth	int32_t	Nein
urlId	string	Nein
userId	string	Nein
anonUserId	string	Nein
contextUserId	string	Nein
hashTag	string	Nein
parentId	string	Nein
direction	SortDirections	Nein

Antwort

Gibt zurück: GetComments_200_response

Beispiel

getComments Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<int32_t> page(1);
boost::optional<int32_t> limit(50);
boost::optional<int32_t> skip(0);
boost::optional<bool> asTree(true);
boost::optional<int32_t> skipChildren(0);
boost::optional<int32_t> limitChildren(10);
boost::optional<int32_t> maxTreeDepth(3);
boost::optional<utility::string_t> urlId(U("/articles/2025/fast-api"));
boost::optional<utility::string_t> userId(U("user@example.com"));
boost::optional<utility::string_t> anonUserId(U("anon-abc-123"));
boost::optional<utility::string_t> contextUserId(U("context-user-789"));
boost::optional<utility::string_t> hashTag(U("release"));
boost::optional<utility::string_t> parentId(U("parent-comment-456"));
boost::optional<SortDirections> direction(SortDirections::DESCENDING);
api->getComments(tenantId, page, limit, skip, asTree, skipChildren, limitChildren, maxTreeDepth, urlId, userId, anonUserId, contextUserId, hashTag, parentId, direction)
.then([](pplx::task<std::shared_ptr<GetComments_200_response>> task){
    try {
        auto response = task.get();
        if (!response) response = std::make_shared<GetComments_200_response>();
    } catch (const std::exception&) {
    }
});

Öffentlich: Kommentare abrufen

req tenantId urlId

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
urlId	string	Ja
page	int32_t	Nein
direction	SortDirections	Nein
sso	string	Nein
skip	int32_t	Nein
skipChildren	int32_t	Nein
limit	int32_t	Nein
limitChildren	int32_t	Nein
countChildren	bool	Nein
fetchPageForCommentId	string	Nein
includeConfig	bool	Nein
countAll	bool	Nein
includei10n	bool	Nein
locale	string	Nein
modules	string	Nein
isCrawler	bool	Nein
includeNotificationCount	bool	Nein
asTree	bool	Nein
maxTreeDepth	int32_t	Nein
useFullTranslationIds	bool	Nein
parentId	string	Nein
searchText	string	Nein
hashTags	vector<string	Nein
userId	string	Nein
customConfigStr	string	Nein
afterCommentId	string	Nein
beforeCommentId	string	Nein

Antwort

Gibt zurück: GetCommentsPublic_200_response

Beispiel

getCommentsPublic Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("article-2026-01-12");
boost::optional<int32_t> page(2);
boost::optional<SortDirections> direction(SortDirections::DESC);
boost::optional<bool> includeConfig(true);
boost::optional<std::vector<utility::string_t>> hashTags(std::vector<utility::string_t>{ U("feature"), U("bug") });
api->getCommentsPublic(
    tenantId,
    urlId,
    page,
    direction,
    boost::optional<utility::string_t>(),
    boost::optional<int32_t>(),
    boost::optional<int32_t>(),
    boost::optional<int32_t>(50),
    boost::optional<int32_t>(),
    boost::optional<bool>(false),
    boost::optional<utility::string_t>(),
    includeConfig,
    boost::optional<bool>(),
    boost::optional<bool>(),
    boost::optional<utility::string_t>(),
    boost::optional<utility::string_t>(),
    boost::optional<bool>(),
    boost::optional<bool>(),
    boost::optional<bool>(),
    boost::optional<int32_t>(),
    boost::optional<bool>(),
    boost::optional<utility::string_t>(),
    boost::optional<utility::string_t>(),
    hashTags,
    boost::optional<utility::string_t>(U("user-789")),
    boost::optional<utility::string_t>(),
    boost::optional<utility::string_t>()
).then([](pplx::task<std::shared_ptr<GetCommentsPublic_200_response>> t){
    try {
        auto resp = t.get();
        auto fallback = std::make_shared<GetCommentsPublic_200_response>();
        (void)(resp ? resp : fallback);
    } catch (...) {}
});

Kommentartext abrufen

Parameter

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

Antwort

Gibt zurück: GetCommentText_200_response

Beispiel

getCommentText Beispiel

Copy

utility::string_t tenantId(U("my-tenant-123"));
utility::string_t commentId(U("cmt-456"));
boost::optional<utility::string_t> editKey(utility::string_t(U("edit-key-789")));
boost::optional<utility::string_t> sso(utility::string_t(U("user@example.com")));
auto task = api->getCommentText(tenantId, commentId, editKey, sso)
    .then([](std::shared_ptr<GetCommentText_200_response> resp){
        if (resp) {
            std::cout << "Comment text retrieved\n";
        } else {
            std::cout << "Comment not found\n";
        }
    });
task.wait();

Benutzernamen von Kommentarabstimmungen abrufen

Parameter

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

Antwort

Gibt zurück: GetCommentVoteUserNames_200_response

Beispiel

getCommentVoteUserNames Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456");
int32_t dir = 1;
boost::optional<utility::string_t> sso{ utility::string_t(U("user@example.com")) };
api->getCommentVoteUserNames(tenantId, commentId, dir, sso)
    .then([](pplx::task<std::shared_ptr<GetCommentVoteUserNames_200_response>> t) {
        try {
            auto resp = t.get();
            if (!resp) resp = std::make_shared<GetCommentVoteUserNames_200_response>();
        } catch (const std::exception&) {
        }
    });

Kommentar sperren

Parameter

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

Antwort

Gibt zurück: LockComment_200_response

Beispiel

lockComment Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456");
utility::string_t broadcastId = U("brdcst-789");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
api->lockComment(tenantId, commentId, broadcastId, sso)
    .then([](pplx::task<std::shared_ptr<LockComment_200_response>> t)
    {
        try
        {
            auto resp = t.get();
            if(!resp)
            {
                resp = std::make_shared<LockComment_200_response>();
            }
        }
        catch(const std::exception& ex)
        {
            (void)ex;
        }
    });

Kommentar anpinnen

Parameter

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

Antwort

Gibt zurück: PinComment_200_response

Beispiel

pinComment Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
utility::string_t broadcastId = U("broadcast-98765");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
api->pinComment(tenantId, commentId, broadcastId, sso)
.then([](pplx::task<std::shared_ptr<PinComment_200_response>> t){
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<PinComment_200_response>();
        (void)resp;
    } catch (...) {}
}).wait();

Kommentar speichern

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
createCommentParams	CreateCommentParams	Ja
isLive	bool	Nein
doSpamCheck	bool	Nein
sendEmails	bool	Nein
populateNotifications	bool	Nein

Antwort

Gibt zurück: SaveComment_200_response

Beispiel

saveComment Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
auto createParamsPtr = std::make_shared<CreateCommentParams>();
createParamsPtr->content = utility::string_t(U("This is a test comment posted via SDK"));
createParamsPtr->authorEmail = utility::string_t(U("user@example.com"));
createParamsPtr->threadId = utility::string_t(U("thread-456"));
boost::optional<bool> isLive(true);
boost::optional<bool> doSpamCheck(false);
boost::optional<bool> sendEmails(true);
boost::optional<bool> populateNotifications(false);
auto task = api->saveComment(tenantId, *createParamsPtr, isLive, doSpamCheck, sendEmails, populateNotifications)
.then([](std::shared_ptr<SaveComment_200_response> resp){
    if (resp) std::cout << "Comment saved successfully\n";
    else std::cout << "Failed to save comment\n";
});
task.wait();

Kommentartext setzen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
broadcastId	string	Ja
commentTextUpdateRequest	CommentTextUpdateRequest	Ja
editKey	string	Nein
sso	string	Nein

Antwort

Gibt zurück: SetCommentText_200_response

Beispiel

setCommentText Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456");
utility::string_t broadcastId = U("bcast-789");
CommentTextUpdateRequest commentTextUpdateRequest;
commentTextUpdateRequest.setText(U("Updated comment text by moderator."));
boost::optional<utility::string_t> editKey = boost::optional<utility::string_t>(U("edit-key-abc123"));
boost::optional<utility::string_t> sso;
api->setCommentText(tenantId, commentId, broadcastId, commentTextUpdateRequest, editKey, sso)
.then([](pplx::task<std::shared_ptr<SetCommentText_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto result = std::make_shared<SetCommentText_200_response>(*resp);
            std::cout << "Comment updated\n";
        } else {
            std::cout << "No response\n";
        }
    } catch (const std::exception &e) {
        std::cerr << "setCommentText error: " << e.what() << '\n';
    }
});

Benutzer vom Kommentar entsperren

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
unBlockFromCommentParams	UnBlockFromCommentParams	Ja
userId	string	Nein
anonUserId	string	Nein

Antwort

Gibt zurück: UnBlockCommentPublic_200_response

Beispiel

Beispiel: unBlockUserFromComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
auto paramsPtr = std::make_shared<UnBlockFromCommentParams>();
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<utility::string_t> anonUserId = boost::none;
api->unBlockUserFromComment(tenantId, commentId, *paramsPtr, userId, anonUserId)
    .then([](std::shared_ptr<UnBlockCommentPublic_200_response> resp){
        (void)resp;
    })
    .wait();

Meldung des Kommentars aufheben

Parameter

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

Antwort

Gibt zurück: FlagComment_200_response

Beispiel

unFlagComment-Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654321");
boost::optional<utility::string_t> userId(U("user@example.com"));
boost::optional<utility::string_t> anonUserId;
auto fallback = std::make_shared<FlagComment_200_response>();
api->unFlagComment(tenantId, commentId, userId, anonUserId)
    .then([fallback](pplx::task<std::shared_ptr<FlagComment_200_response>> t) {
        try {
            auto resp = t.get();
            if (!resp) resp = fallback;
        } catch (...) {
        }
    });

Kommentar entsperren

Parameter

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

Antwort

Gibt zurück: LockComment_200_response

Beispiel

unLockComment Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654");
utility::string_t broadcastId = U("brd-456");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
auto dummyResp = std::make_shared<LockComment_200_response>();
api->unLockComment(tenantId, commentId, broadcastId, sso)
.then([](pplx::task<std::shared_ptr<LockComment_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            std::cout << "Comment unlocked successfully\n";
        } else {
            std::cout << "Unlock returned empty response\n";
        }
    } catch (const std::exception& e) {
        std::cerr << "Error unlocking comment: " << e.what() << '\n';
    }
});

Kommentar entpinnen

Parameter

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

Antwort

Gibt zurück: PinComment_200_response

Beispiel

Beispiel für unPinComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
utility::string_t broadcastId = U("brd-98765");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
auto defaultResp = std::make_shared<PinComment_200_response>();
api->unPinComment(tenantId, commentId, broadcastId, sso)
.then([defaultResp](pplx::task<std::shared_ptr<PinComment_200_response>> task) {
    try {
        auto resp = task.get();
        if (!resp) resp = defaultResp;
        std::cout << "unPinComment completed; response pointer " << (resp ? "valid" : "null") << std::endl;
    } catch (const std::exception &e) {
        std::cerr << "unPinComment failed: " << e.what() << std::endl;
    }
});

Kommentar aktualisieren

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
updatableCommentParams	UpdatableCommentParams	Ja
contextUserId	string	Nein
doSpamCheck	bool	Nein
isLive	bool	Nein

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

updateComment Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto commentId = utility::string_t(U("comment-456"));
auto body = std::make_shared<UpdatableCommentParams>();
body->content = utility::string_t(U("Updated comment text: fixed a typo and clarified meaning."));
boost::optional<utility::string_t> contextUserId(utility::string_t(U("user@example.com")));
boost::optional<bool> doSpamCheck(true);
boost::optional<bool> isLive(false);
api->updateComment(tenantId, commentId, body, contextUserId, doSpamCheck, isLive)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
    try {
        auto result = t.get();
        (void)result;
    } catch (...) {}
});

Kommentar bewerten

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
urlId	string	Ja
broadcastId	string	Ja
voteBodyParams	VoteBodyParams	Ja
sessionId	string	Nein
sso	string	Nein

Antwort

Gibt zurück: VoteComment_200_response

Beispiel

voteComment Beispiel

Copy

VoteBodyParams voteBodyParams;
utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-7890");
utility::string_t urlId = U("/articles/2025/how-to-cpprest");
utility::string_t broadcastId = U("broadcast-321");
boost::optional<utility::string_t> sessionId = boost::optional<utility::string_t>(U("sess-0a1b2c"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-jwt-xyz"));
api->voteComment(tenantId, commentId, urlId, broadcastId, voteBodyParams, sessionId, sso)
    .then([](pplx::task<std::shared_ptr<VoteComment_200_response>> t) {
        try {
            auto resp = t.get();
            if (!resp) resp = std::make_shared<VoteComment_200_response>();
        } catch (...) {
        }
    });

Domain-Konfiguration hinzufügen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
addDomainConfigParams	AddDomainConfigParams	Ja

Antwort

Gibt zurück: AddDomainConfig_200_response

Beispiel

addDomainConfig Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
AddDomainConfigParams params;
params.domain = U("comments.example.com");
params.allowSubdomains = boost::optional<bool>(true);
params.contactEmail = boost::optional<utility::string_t>(U("admin@example.com"));
api->addDomainConfig(tenantId, params)
.then([](pplx::task<std::shared_ptr<AddDomainConfig_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<AddDomainConfig_200_response>(*resp);
            (void)copy;
        }
    } catch (const std::exception& e) {
        (void)e;
    }
});

Domain-Konfiguration löschen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
domain	string	Ja

Antwort

Gibt zurück: DeleteDomainConfig_200_response

Beispiel

deleteDomainConfig Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domain = U("comments.example.com");
boost::optional<utility::string_t> ifMatch = boost::optional<utility::string_t>(U("W/\"abc123\""));
api->deleteDomainConfig(tenantId, domain)
.then([](pplx::task<std::shared_ptr<DeleteDomainConfig_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            auto resultCopy = std::make_shared<DeleteDomainConfig_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

Domain-Konfiguration abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
domain	string	Ja

Antwort

Gibt zurück: GetDomainConfig_200_response

Beispiel

getDomainConfig Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domain = U("example.com");
boost::optional<utility::string_t> env = boost::optional<utility::string_t>(U("production"));
api->getDomainConfig(tenantId, domain).then([=](pplx::task<std::shared_ptr<GetDomainConfig_200_response>> t) {
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<GetDomainConfig_200_response>();
        std::cout << "Domain config received for " << utility::conversions::to_utf8string(domain) << '\n';
    } catch (const std::exception &ex) {
        std::cerr << "Failed to get domain config: " << ex.what() << '\n';
    }
});

Domain-Konfigurationen abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja

Antwort

Gibt zurück: GetDomainConfigs_200_response

Beispiel

getDomainConfigs Beispiel

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> requestId = utility::conversions::to_string_t("req-789");
api->getDomainConfigs(tenantId)
    .then([requestId](pplx::task<std::shared_ptr<GetDomainConfigs_200_response>> t){
        try {
            auto resp = t.get();
            auto copy = std::make_shared<GetDomainConfigs_200_response>(*resp);
            if (requestId) std::cout << "Request id present\n";
            std::cout << "Domain configs loaded\n";
        } catch (const std::exception &e) {
            std::cerr << "Error: " << e.what() << '\n';
        }
    }).wait();

Domain-Konfiguration teilweise aktualisieren

Parameter

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

Antwort

Gibt zurück: GetDomainConfig_200_response

Beispiel

patchDomainConfig Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domainToUpdate = U("example.com");
PatchDomainConfigParams params;
params.adminEmail = boost::optional<utility::string_t>(U("admin@example.com"));
params.enableSso = boost::optional<bool>(true);
params.ssoRedirectUrl = boost::optional<utility::string_t>(U("https://auth.example.com/callback"));
api->patchDomainConfig(tenantId, domainToUpdate, params)
    .then([](pplx::task<std::shared_ptr<GetDomainConfig_200_response>> task){
        try {
            auto resp = task.get();
            if (resp) {
                auto updated = std::make_shared<GetDomainConfig_200_response>(*resp);
            }
        } catch (const std::exception& e) {
            auto err = std::string(e.what());
        }
    });

Domain-Konfiguration ersetzen

Parameter

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

Antwort

Gibt zurück: GetDomainConfig_200_response

Beispiel

putDomainConfig Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domainToUpdate = U("comments.myapp.com");
auto params = std::make_shared<UpdateDomainConfigParams>();
params->displayName = utility::string_t(U("My App Comments"));
params->enabled = boost::optional<bool>(true);
params->contactEmail = boost::optional<utility::string_t>(U("admin@myapp.com"));
api->putDomainConfig(tenantId, domainToUpdate, *params)
.then([](pplx::task<std::shared_ptr<GetDomainConfig_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto updated = resp;
        }
    } catch (const std::exception& e) {
    }
});

E-Mail-Vorlage erstellen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createEmailTemplateBody	CreateEmailTemplateBody	Ja

Antwort

Gibt zurück: CreateEmailTemplate_200_response

Beispiel

createEmailTemplate Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
auto body = std::make_shared<CreateEmailTemplateBody>();
body->name = utility::string_t(U("Welcome Email"));
body->subject = utility::string_t(U("Welcome to Our Service"));
body->fromEmail = utility::string_t(U("no-reply@mycompany.com"));
body->fromName = utility::string_t(U("MyCompany Support"));
body->html = utility::string_t(U("<p>Hello {{user.name}}, welcome to MyCompany.</p>"));
body->description = boost::optional<utility::string_t>(utility::string_t(U("Onboarding welcome template")));
api->createEmailTemplate(tenantId, *body)
.then([](pplx::task<std::shared_ptr<CreateEmailTemplate_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            bool created = true;
            (void)created;
        }
    } catch (const std::exception&) {
    }
});

E-Mail-Vorlage löschen

Parameter

Name	Type	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

deleteEmailTemplate Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email-template-456");
boost::optional<utility::string_t> requestNote = boost::optional<utility::string_t>(U("remove-obsolete"));
auto fallback = std::make_shared<FlagCommentPublic_200_response>();
api->deleteEmailTemplate(tenantId, templateId)
.then([requestNote, fallback](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) -> pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> {
    try {
        auto resp = t.get();
        if (resp) return pplx::task_from_result(resp);
        if (requestNote) return pplx::task_from_result(fallback);
        return pplx::task_from_result<std::shared_ptr<FlagCommentPublic_200_response>>(nullptr);
    } catch (...) {
        return pplx::task_from_result<std::shared_ptr<FlagCommentPublic_200_response>>(nullptr);
    }
});

Renderfehler der E-Mail-Vorlage löschen

Parameter

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

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

deleteEmailTemplateRenderError Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email-template-456");
utility::string_t errorId = U("render-error-789");
auto placeholder = std::make_shared<FlagCommentPublic_200_response>();
boost::optional<utility::string_t> operatorNote = boost::none;
operatorNote = U("auto-resolved");
api->deleteEmailTemplateRenderError(tenantId, templateId, errorId)
    .then([operatorNote, templateId](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> previous) {
        try {
            auto resp = previous.get();
            if (resp) {
                std::cout << "Successfully deleted render error for template: " << utility::conversions::to_utf8string(templateId) << std::endl;
            }
            if (operatorNote) {
                std::cout << "Note: " << utility::conversions::to_utf8string(operatorNote.value()) << std::endl;
            }
        } catch (const std::exception &e) {
            std::cerr << "API error: " << e.what() << std::endl;
        }
    });

E-Mail-Vorlage abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: GetEmailTemplate_200_response

Beispiel

getEmailTemplate Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email-001");
boost::optional<utility::string_t> preferLocale = boost::optional<utility::string_t>(U("en-US"));
api->getEmailTemplate(tenantId, templateId)
    .then([preferLocale](std::shared_ptr<GetEmailTemplate_200_response> resp) {
        auto templateResp = resp ? resp : std::make_shared<GetEmailTemplate_200_response>();
        if (preferLocale) {
            (void)preferLocale;
        }
        return templateResp;
    });

Definitionen der E-Mail-Vorlagen abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja

Antwort

Gibt zurück: GetEmailTemplateDefinitions_200_response

Beispiel

getEmailTemplateDefinitions Beispiel

Copy

boost::optional<utility::string_t> tenantIdOpt = utility::string_t(U("my-tenant-123"));
api->getEmailTemplateDefinitions(tenantIdOpt.value())
.then([](pplx::task<std::shared_ptr<GetEmailTemplateDefinitions_200_response>> task) {
    try {
        auto resp = task.get();
        auto localCopy = std::make_shared<GetEmailTemplateDefinitions_200_response>(*resp);
        (void)localCopy;
    } catch (const std::exception& e) {
        auto fallback = std::make_shared<GetEmailTemplateDefinitions_200_response>();
        (void)fallback;
    }
});

Renderfehler der E-Mail-Vorlagen abrufen

Parameter

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

Antwort

Gibt zurück: GetEmailTemplateRenderErrors_200_response

Beispiel

Beispiel für getEmailTemplateRenderErrors

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("email-template-789");
boost::optional<double> skip{10.0};
auto defaultResp = std::make_shared<GetEmailTemplateRenderErrors_200_response>();
api->getEmailTemplateRenderErrors(tenantId, id, skip).then([defaultResp](pplx::task<std::shared_ptr<GetEmailTemplateRenderErrors_200_response>> t){
    try {
        auto resp = t.get();
        if(!resp) resp = defaultResp;
        std::wcout << (resp ? U("Received render errors response\n") : U("No response\n"));
    } catch(...) {
        std::wcout << U("Failed to retrieve render errors\n");
    }
});

E-Mail-Vorlagen abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
skip	double	Nein

Antwort

Gibt zurück: GetEmailTemplates_200_response

Beispiel

getEmailTemplates Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = 10.0;
api->getEmailTemplates(tenantId, skip).then([](pplx::task<std::shared_ptr<GetEmailTemplates_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<GetEmailTemplates_200_response>(*resp);
        }
    } catch (const std::exception& e) {
        (void)e;
    }
});

E-Mail-Vorlage rendern

Parameter

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

Antwort

Gibt zurück: RenderEmailTemplate_200_response

Beispiel

renderEmailTemplate Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
RenderEmailTemplateBody renderEmailTemplateBody;
renderEmailTemplateBody.setTemplateName(U("welcome_wagon"));
renderEmailTemplateBody.setRecipient(U("alice@example.com"));
web::json::value vars;
vars[U("firstName")] = web::json::value::string(U("Alice"));
renderEmailTemplateBody.setVariables(vars);
boost::optional<utility::string_t> locale = boost::optional<utility::string_t>(U("en-US"));
auto placeholder = std::make_shared<RenderEmailTemplate_200_response>();
api->renderEmailTemplate(tenantId, renderEmailTemplateBody, locale)
.then([](pplx::task<std::shared_ptr<RenderEmailTemplate_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            std::cout << "Email template rendered successfully" << std::endl;
        } else {
            std::cerr << "No response returned" << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << "Render failed: " << e.what() << std::endl;
    }
});

E-Mail-Vorlage aktualisieren

Parameter

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

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

updateEmailTemplate Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email-01");
UpdateEmailTemplateBody updateBody;
boost::optional<utility::string_t> optionalFrom = boost::optional<utility::string_t>(U("no-reply@myapp.com"));
updateBody.from = optionalFrom;
updateBody.subject = U("Welcome to MyApp");
updateBody.html = U("<p>Hi {{displayName}}, welcome to MyApp!</p>");
auto bodyPtr = std::make_shared<UpdateEmailTemplateBody>(updateBody);
api->updateEmailTemplate(tenantId, templateId, *bodyPtr)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            std::cout << "Email template updated successfully\n";
        } else {
            std::cout << "Unexpected empty response\n";
        }
    } catch (const std::exception &e) {
        std::cerr << "Update failed: " << e.what() << '\n';
    }
});

Ereignisprotokoll abrufen

req tenantId urlId userIdWS

Parameter

Name	Type	Required
tenantId	string	Ja
urlId	string	Ja
userIdWS	string	Ja
startTime	int64_t	Ja
endTime	int64_t	Ja

Antwort

Gibt zurück: GetEventLog_200_response

Beispiel

getEventLog Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("article-456");
utility::string_t userIdWS = U("user@example.com");
int64_t startTime = 1672531200LL;
boost::optional<int64_t> endTimeOpt = 1672617600LL;
api->getEventLog(tenantId, urlId, userIdWS, startTime, *endTimeOpt)
    .then([](pplx::task<std::shared_ptr<GetEventLog_200_response>> t){
        try {
            auto resp = t.get();
            if (!resp) resp = std::make_shared<GetEventLog_200_response>();
        } catch (const std::exception&) {}
    });

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	Ja

Antwort

Gibt zurück: GetEventLog_200_response

Beispiel

getGlobalEventLog Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t defaultUrlId = U("article-456");
boost::optional<utility::string_t> maybeUrlId = boost::optional<utility::string_t>(U("article-456"));
utility::string_t urlId = maybeUrlId ? *maybeUrlId : defaultUrlId;
utility::string_t userIdWS = U("user@example.com");
int64_t startTime = 1622505600000LL;
int64_t endTime = 1622592000000LL;
auto defaultResp = std::make_shared<GetEventLog_200_response>();
api->getGlobalEventLog(tenantId, urlId, userIdWS, startTime, endTime)
.then([](pplx::task<std::shared_ptr<GetEventLog_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) std::cout << "Received event log with entries\n";
        else std::cout << "No event log returned\n";
    } catch (const std::exception &e) {
        std::cerr << "getGlobalEventLog failed: " << e.what() << '\n';
    }
});

Feed-Beitrag erstellen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
createFeedPostParams	CreateFeedPostParams	Ja
broadcastId	string	Nein
isLive	bool	Nein
doSpamCheck	bool	Nein
skipDupCheck	bool	Nein

Antwort

Gibt zurück: CreateFeedPost_200_response

Beispiel

Beispiel für createFeedPost

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateFeedPostParams params;
params.title = utility::string_t(U("Weekly Product Update"));
params.content = utility::string_t(U("This week we shipped several improvements to the API."));
params.authorEmail = utility::string_t(U("jane.doe@example.com"));
boost::optional<utility::string_t> broadcastId = boost::optional<utility::string_t>(U("broadcast-456"));
boost::optional<bool> isLive = boost::optional<bool>(true);
boost::optional<bool> doSpamCheck = boost::optional<bool>(false);
boost::optional<bool> skipDupCheck = boost::optional<bool>(false);
api->createFeedPost(tenantId, params, broadcastId, isLive, doSpamCheck, skipDupCheck)
.then([](pplx::task<std::shared_ptr<CreateFeedPost_200_response>> t){
    try {
        auto resp = t.get();
        auto copy = std::make_shared<CreateFeedPost_200_response>(*resp);
    } catch (...) {}
});

Öffentlich: Feed-Beitrag erstellen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
createFeedPostParams	CreateFeedPostParams	Ja
broadcastId	string	Nein
sso	string	Nein

Antwort

Gibt zurück: CreateFeedPostPublic_200_response

Beispiel

createFeedPostPublic Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto paramsPtr = std::make_shared<CreateFeedPostParams>();
paramsPtr->title = utility::string_t(U("Weekly Release Notes"));
paramsPtr->content = utility::string_t(U("We've deployed version 2.4.1 with bug fixes and UX improvements."));
paramsPtr->authorEmail = utility::string_t(U("alice@example.com"));
boost::optional<utility::string_t> broadcastId = utility::string_t(U("broadcast-456"));
boost::optional<utility::string_t> sso = utility::string_t(U("sso-token-abc123"));
api->createFeedPostPublic(tenantId, *paramsPtr, broadcastId, sso)
    .then([](pplx::task<std::shared_ptr<CreateFeedPostPublic_200_response>> t) {
        try {
            auto resp = t.get();
            if (resp) std::cout << "Feed post created successfully\n";
        } catch (const std::exception& e) {
            std::cerr << "Failed to create feed post: " << e.what() << '\n';
        }
    });

Öffentlich: Feed-Beitrag löschen

Parameter

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

Antwort

Gibt zurück: DeleteFeedPostPublic_200_response

Beispiel

deleteFeedPostPublic Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t postId = U("post-456");
boost::optional<utility::string_t> broadcastId = boost::optional<utility::string_t>(U("broadcast-789"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
api->deleteFeedPostPublic(tenantId, postId, broadcastId, sso)
.then([](pplx::task<std::shared_ptr<DeleteFeedPostPublic_200_response>> t){
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<DeleteFeedPostPublic_200_response>();
        (void)resp;
    } catch (const std::exception&) {
    }
});

Feed-Beiträge abrufen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
afterId	string	Nein
limit	int32_t	Nein
tags	vector<string	Nein

Antwort

Gibt zurück: GetFeedPosts_200_response

Beispiel

Beispiel für getFeedPosts

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> afterId(utility::string_t(U("post_456")));
boost::optional<int32_t> limit(50);
std::vector<utility::string_t> tagVec{U("news"), U("announcement")};
boost::optional<std::vector<utility::string_t>> tags(tagVec);
api->getFeedPosts(tenantId, afterId, limit, tags)
.then([](std::shared_ptr<GetFeedPosts_200_response> resp) {
    auto copy = std::make_shared<GetFeedPosts_200_response>(*resp);
    (void)copy;
});

Öffentlich: Feed-Beiträge abrufen

req tenantId afterId

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
afterId	string	Nein
limit	int32_t	Nein
tags	vector<string	Nein
sso	string	Nein
isCrawler	bool	Nein
includeUserInfo	bool	Nein

Antwort

Gibt zurück: GetFeedPostsPublic_200_response

Beispiel

getFeedPostsPublic Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> afterId = boost::optional<utility::string_t>(U("post_abc123"));
boost::optional<int32_t> limit = boost::optional<int32_t>(20);
boost::optional<std::vector<utility::string_t>> tags = boost::optional<std::vector<utility::string_t>>(std::vector<utility::string_t>{U("news"), U("tech")});
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<bool> isCrawler = boost::optional<bool>(false);
boost::optional<bool> includeUserInfo = boost::optional<bool>(true);
api->getFeedPostsPublic(tenantId, afterId, limit, tags, sso, isCrawler, includeUserInfo)
.then([](pplx::task<std::shared_ptr<GetFeedPostsPublic_200_response>> t){
    try {
        std::shared_ptr<GetFeedPostsPublic_200_response> resp = t.get();
        auto marker = std::make_shared<int>(1);
        if (resp) { (void)marker; }
    } catch (const std::exception&) {
    }
});

Statistiken zu Feed-Beiträgen abrufen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
postIds	vector<string	Ja
sso	string	Nein

Antwort

Gibt zurück: GetFeedPostsStats_200_response

Beispiel

getFeedPostsStats Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
std::vector<utility::string_t> postIds{ U("post-abc-001"), U("post-xyz-123") };
boost::optional<utility::string_t> sso(U("user@example.com"));
api->getFeedPostsStats(tenantId, postIds, sso)
    .then([](pplx::task<std::shared_ptr<GetFeedPostsStats_200_response>> t)
    {
        try {
            auto resp = t.get();
            auto respCopy = resp ? std::make_shared<GetFeedPostsStats_200_response>(*resp) : nullptr;
            (void)respCopy;
        } catch (const std::exception&) {}
    });

Öffentlich: Nutzerreaktionen abrufen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
postIds	vector<string	Nein
sso	string	Nein

Antwort

Gibt zurück: GetUserReactsPublic_200_response

Beispiel

getUserReactsPublic Beispiel

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
std::vector<utility::string_t> postIdsVec = {
    utility::conversions::to_string_t("post-456"),
    utility::conversions::to_string_t("post-789")
};
boost::optional<std::vector<utility::string_t>> postIdsOpt = postIdsVec;
boost::optional<utility::string_t> ssoOpt = utility::conversions::to_string_t("user@example.com");
api->getUserReactsPublic(tenantId, postIdsOpt, ssoOpt)
    .then([](pplx::task<std::shared_ptr<GetUserReactsPublic_200_response>> t) {
        try {
            auto resp = t.get();
            if (!resp) resp = std::make_shared<GetUserReactsPublic_200_response>();
        } catch (const std::exception&) {
        }
    });

Öffentlich: Auf Feed-Beitrag reagieren

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
postId	string	Ja
reactBodyParams	ReactBodyParams	Ja
isUndo	bool	Nein
broadcastId	string	Nein
sso	string	Nein

Antwort

Gibt zurück: ReactFeedPostPublic_200_response

Beispiel

reactFeedPostPublic Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t postId = U("post-987");
ReactBodyParams reactBodyParams;
reactBodyParams.userId = U("jane.doe@example.com");
reactBodyParams.reaction = U("like");
boost::optional<bool> isUndo = boost::optional<bool>(false);
boost::optional<utility::string_t> broadcastId = boost::optional<utility::string_t>(U("broadcast-001"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-token-xyz"));
api->reactFeedPostPublic(tenantId, postId, reactBodyParams, isUndo, broadcastId, sso)
    .then([](pplx::task<std::shared_ptr<ReactFeedPostPublic_200_response>> task) {
        try {
            auto resp = task.get();
            auto out = resp ? resp : std::make_shared<ReactFeedPostPublic_200_response>();
            std::cout << "Reaction processed\n";
        } catch (const std::exception &e) {
            std::cerr << "React failed: " << e.what() << '\n';
        }
    });

Feed-Beitrag aktualisieren

Parameter

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

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

updateFeedPost Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t postId = U("post-987654321");
FeedPost feedPost;
feedPost.title = U("Weekly status update");
feedPost.content = U("Completed the migration of the comments service to the new infra.");
feedPost.authorEmail = U("developer@acme-corp.com");
boost::optional<utility::string_t> summary = boost::optional<utility::string_t>(U("Migration complete"));
feedPost.summary = summary;
auto updateTask = api->updateFeedPost(tenantId, postId, feedPost)
    .then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
        try {
            auto resp = t.get();
            if (resp) {
                auto cloned = std::make_shared<FlagCommentPublic_200_response>(*resp);
            }
        } catch (...) {
        }
    });

Öffentlich: Feed-Beitrag aktualisieren

Parameter

Name	Type	Erforderlich
tenantId	string	Ja
postId	string	Ja
updateFeedPostParams	UpdateFeedPostParams	Ja
broadcastId	string	Nein
sso	string	Nein

Antwort

Gibt zurück: CreateFeedPostPublic_200_response

Beispiel

updateFeedPostPublic Beispiel

Copy

utility::string_t tenantId = U"my-tenant-123";
utility::string_t postId = U"post-456";
UpdateFeedPostParams params;
boost::optional<utility::string_t> broadcastId = utility::string_t(U"broadcast-789");
boost::optional<utility::string_t> sso = utility::string_t(U"user@example.com");
api->updateFeedPostPublic(tenantId, postId, params, broadcastId, sso)
.then([](pplx::task<std::shared_ptr<CreateFeedPostPublic_200_response>> task){
    try {
        auto resp = task.get();
        if (!resp) resp = std::make_shared<CreateFeedPostPublic_200_response>();
        (void)resp;
    } catch (...) {}
});

Öffentlich: Kommentar melden

Parameter

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

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

flagCommentPublic Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-789012");
bool isFlagged = true;
boost::optional<utility::string_t> sso{ U("user@example.com") };
api->flagCommentPublic(tenantId, commentId, isFlagged, sso)
.then([](std::shared_ptr<FlagCommentPublic_200_response> resp){
    auto respCopy = std::make_shared<FlagCommentPublic_200_response>(*resp);
    return respCopy;
});

Hashtag hinzufügen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Nein
createHashTagBody	CreateHashTagBody	Nein

Antwort

Rückgabe: AddHashTag_200_response

Beispiel

addHashTag Beispiel

Copy

boost::optional<utility::string_t> tenantId(U("my-tenant-123"));
auto bodyPtr = std::make_shared<CreateHashTagBody>();
bodyPtr->name = U("release");
bodyPtr->color = U("#00aaff");
boost::optional<CreateHashTagBody> createBody(*bodyPtr);
api->addHashTag(tenantId, createBody).then([](pplx::task<std::shared_ptr<AddHashTag_200_response>> t){
    try {
        auto resp = t.get();
        (void)resp;
    } catch(...) {}
});

Hashtags massenhaft hinzufügen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Nein
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Nein

Antwort

Gibt zurück: AddHashTagsBulk_200_response

Beispiel

addHashTagsBulk Beispiel

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
auto bodyPtr = std::make_shared<BulkCreateHashTagsBody>();
boost::optional<utility::string_t> optTenant(tenantId);
boost::optional<BulkCreateHashTagsBody> optBody(*bodyPtr);
api->addHashTagsBulk(optTenant, optBody).then([](pplx::task<std::shared_ptr<AddHashTagsBulk_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) std::cout << "Bulk hashtags added for tenant\n";
    } catch (const std::exception &e) {
        std::cerr << "addHashTagsBulk error: " << e.what() << '\n';
    }
});

Hashtag löschen

Parameter

Name	Type	Erforderlich
tag	string	Ja
tenantId	string	Nein
deleteHashTagRequest	DeleteHashTag_request	Nein

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

deleteHashTag Beispiel

Copy

utility::string_t tag = U("inappropriate");
boost::optional<utility::string_t> tenantId = boost::optional<utility::string_t>(U("my-tenant-123"));
DeleteHashTag_request req;
boost::optional<DeleteHashTag_request> optReq = boost::optional<DeleteHashTag_request>(req);
api->deleteHashTag(tag, tenantId, optReq)
.then([](std::shared_ptr<FlagCommentPublic_200_response> resp){
    auto out = std::make_shared<FlagCommentPublic_200_response>(*resp);
    std::cout << "Hashtag removed successfully for tenant\n";
    return out;
}).wait();

Hashtags abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
page	double	Nein

Antwort

Gibt zurück: GetHashTags_200_response

Beispiel

getHashTags Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> page = 2.0;
auto defaultResp = std::make_shared<GetHashTags_200_response>();
api->getHashTags(tenantId, page).then([defaultResp](pplx::task<std::shared_ptr<GetHashTags_200_response>> t) {
    try {
        auto resp = t.get();
        if(!resp) resp = defaultResp;
        std::cout << "getHashTags completed; response object " << (resp ? "present" : "absent") << std::endl;
    } catch(const std::exception& e) {
        std::cout << "getHashTags error: " << e.what() << std::endl;
    }
});

Hashtag teilweise aktualisieren

Parameter

Name	Typ	Erforderlich
tag	string	Yes
tenantId	string	No
updateHashTagBody	UpdateHashTagBody	No

Antwort

Gibt zurück: PatchHashTag_200_response

Beispiel

patchHashTag Beispiel

Copy

utility::string_t tag = U("release-1.0");
boost::optional<utility::string_t> tenantId = boost::optional<utility::string_t>(U("my-tenant-123"));
UpdateHashTagBody body;
boost::optional<UpdateHashTagBody> updateBody = boost::optional<UpdateHashTagBody>(body);
api->patchHashTag(tag, tenantId, updateBody)
.then([](pplx::task<std::shared_ptr<PatchHashTag_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            auto copied = std::make_shared<PatchHashTag_200_response>(*resp);
            std::cout << "PatchHashTag succeeded" << std::endl;
        } else {
            std::cout << "PatchHashTag returned no data" << std::endl;
        }
    } catch (const std::exception &e) {
        std::cerr << "PatchHashTag error: " << e.what() << std::endl;
    }
});

Moderator erstellen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createModeratorBody	CreateModeratorBody	Ja

Antwort

Gibt zurück: CreateModerator_200_response

Beispiel

createModerator Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateModeratorBody createModeratorBody;
createModeratorBody.email = U("moderator@example.com");
createModeratorBody.displayName = U("Support Moderator");
createModeratorBody.roles = std::vector<utility::string_t>{ U("moderator"), U("support") };
createModeratorBody.notes = boost::optional<utility::string_t>(U("Temporary moderator for Q1"));
api->createModerator(tenantId, createModeratorBody)
.then([](pplx::task<std::shared_ptr<CreateModerator_200_response>> t)
{
    try
    {
        auto resp = t.get();
        auto respCopy = std::make_shared<CreateModerator_200_response>(*resp);
        (void)respCopy;
    }
    catch (const std::exception&)
    {
    }
});

Moderator löschen

Parameter

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

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

deleteModerator Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t moderatorId = U("moderator-456");
boost::optional<utility::string_t> sendEmail = boost::optional<utility::string_t>(U("moderator@notifications.example.com"));
api->deleteModerator(tenantId, moderatorId, sendEmail)
    .then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
        try {
            auto resp = t.get();
            if (!resp) resp = std::make_shared<FlagCommentPublic_200_response>();
            return resp;
        } catch (const std::exception&) {
            return std::make_shared<FlagCommentPublic_200_response>();
        }
    });

Moderator abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: GetModerator_200_response

Beispiel

getModerator Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t moderatorId = U("moderator-456");
boost::optional<utility::string_t> requestLocale = U("en-US");
auto fallbackModerator = std::make_shared<GetModerator_200_response>();
api->getModerator(tenantId, moderatorId)
    .then([fallbackModerator, requestLocale](std::shared_ptr<GetModerator_200_response> resp) -> pplx::task<std::shared_ptr<GetModerator_200_response>> {
        auto moderator = resp ? resp : fallbackModerator;
        if (requestLocale) { auto loc = *requestLocale; (void)loc; }
        return pplx::task_from_result(moderator);
    })
    .then([](std::shared_ptr<GetModerator_200_response> finalResp) -> void {
        (void)finalResp;
    });

Moderatoren abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
skip	double	Nein

Antwort

Gibt zurück: GetModerators_200_response

Beispiel

getModerators Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = boost::optional<double>(10);
auto task = api->getModerators(tenantId, skip)
    .then([](std::shared_ptr<GetModerators_200_response> resp) {
        if (!resp) {
            std::cout << "No moderators returned\n";
            return;
        }
        auto copy = std::make_shared<GetModerators_200_response>(*resp);
        std::cout << "Retrieved moderators\n";
    });
task.wait();

Einladung senden

Parameter

Name	Type	Erforderlich
tenantId	string	Ja
id	string	Ja
fromName	string	Ja

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

sendInvite Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("comment-456");
utility::string_t fromName = U("moderator@example.com");
boost::optional<utility::string_t> inviteNote = boost::optional<utility::string_t>(U("Please review this flagged comment"));
auto task = api->sendInvite(tenantId, id, fromName)
    .then([inviteNote](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) -> std::shared_ptr<FlagCommentPublic_200_response> {
        try {
            auto resp = t.get();
            auto wrapped = std::make_shared<FlagCommentPublic_200_response>(*resp);
            (void)inviteNote;
            return wrapped;
        } catch (...) {
            throw;
        }
    });

Moderator aktualisieren

Parameter

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

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

Beispiel für updateModerator

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t moderatorId = U("moderator-456");
auto bodyPtr = std::make_shared<UpdateModeratorBody>();
bodyPtr->email = utility::string_t(U("mod.jane@example.com"));
bodyPtr->displayName = boost::optional<utility::string_t>(utility::string_t(U("Jane Moderator")));
bodyPtr->enabled = boost::optional<bool>(true);
api->updateModerator(tenantId, moderatorId, *bodyPtr).then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            std::cout << "Moderator updated successfully" << std::endl;
        }
    } catch (const std::exception &e) {
        std::cerr << "Update failed: " << e.what() << std::endl;
    }
});

Benachrichtigungsanzahl löschen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

Beispiel für deleteNotificationCount

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t notifId = U("notification-456");
boost::optional<utility::string_t> actingUser = boost::optional<utility::string_t>(U("moderator@example.com"));
api->deleteNotificationCount(tenantId, notifId)
.then([actingUser](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<FlagCommentPublic_200_response>();
        if (actingUser) std::cout << "Actor: " << actingUser->c_str() << "\n";
        std::cout << "Notification count cleared\n";
    } catch (const std::exception &e) {
        std::cout << "Failed: " << e.what() << "\n";
    }
});

Zwischengespeicherte Benachrichtigungsanzahl abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Rückgabe: GetCachedNotificationCount_200_response

Beispiel

getCachedNotificationCount Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user@example.com");
boost::optional<utility::string_t> opt_status = boost::optional<utility::string_t>(U("unread"));
api->getCachedNotificationCount(tenantId, userId)
    .then([=](pplx::task<std::shared_ptr<GetCachedNotificationCount_200_response>> t){
        try {
            std::shared_ptr<GetCachedNotificationCount_200_response> resp = t.get();
            if(!resp) return;
            auto copy = std::make_shared<GetCachedNotificationCount_200_response>(*resp);
        } catch(const std::exception &){
        }
    });

Benachrichtigungsanzahl abrufen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
userId	string	Nein
urlId	string	Nein
fromCommentId	string	Nein
viewed	bool	Nein
type	string	Nein

Antwort

Rückgabe: GetNotificationCount_200_response

Beispiel

getNotificationCount Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> userId = U("user@example.com");
boost::optional<utility::string_t> urlId = U("https://www.example.com/article/456");
boost::optional<utility::string_t> fromCommentId = U("cmt-789");
boost::optional<bool> viewed = true;
boost::optional<utility::string_t> type = U("reply");
api->getNotificationCount(tenantId, userId, urlId, fromCommentId, viewed, type)
    .then([](pplx::task<std::shared_ptr<GetNotificationCount_200_response>> task){
        try {
            auto resp = task.get();
            auto result = resp ? resp : std::make_shared<GetNotificationCount_200_response>();
        } catch (const std::exception&) {
        }
    });

Benachrichtigungen abrufen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
userId	string	Nein
urlId	string	Nein
fromCommentId	string	Nein
viewed	bool	Nein
type	string	Nein
skip	double	Nein

Antwort

Gibt zurück: GetNotifications_200_response

Beispiel

getNotifications Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<utility::string_t> urlId = boost::optional<utility::string_t>(U("https://example.com/posts/42"));
boost::optional<utility::string_t> fromCommentId = boost::optional<utility::string_t>(U("cmt-98765"));
boost::optional<bool> viewed = boost::optional<bool>(true);
boost::optional<utility::string_t> type = boost::optional<utility::string_t>(U("reply"));
boost::optional<double> skip = boost::optional<double>(0.0);
api->getNotifications(tenantId, userId, urlId, fromCommentId, viewed, type, skip)
.then([](pplx::task<std::shared_ptr<GetNotifications_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto processed = std::make_shared<GetNotifications_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

Benachrichtigung aktualisieren

Parameter

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

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

Beispiel für updateNotification

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t notificationId = U("notif-456");
UpdateNotificationBody updateNotificationBody;
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("moderator@example.com"));
api->updateNotification(tenantId, notificationId, updateNotificationBody, userId)
.then([=](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            auto respCopy = std::make_shared<FlagCommentPublic_200_response>(*resp);
            std::cout << "Notification updated successfully\n";
        } else {
            std::cout << "No response received\n";
        }
    } catch (const std::exception &e) {
        std::cerr << "Update failed: " << e.what() << "\n";
    }
});

Seite hinzufügen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createAPIPageData	CreateAPIPageData	Ja

Antwort

Gibt zurück: AddPageAPIResponse

Beispiel

addPage Beispiel

Copy

auto pageData = std::make_shared<CreateAPIPageData>();
pageData->url = utility::string_t(U("https://example.com/articles/2025-modern-cpp"));
pageData->title = utility::string_t(U("Modern C++ Patterns"));
pageData->description = boost::optional<utility::string_t>(utility::string_t(U("Practical patterns for modern C++ development")));
pageData->authorEmail = boost::optional<utility::string_t>(utility::string_t(U("dev@company.com")));
pageData->published = boost::optional<bool>(true);
api->addPage(utility::string_t(U("my-tenant-123")), *pageData)
.then([](pplx::task<std::shared_ptr<AddPageAPIResponse>> t){
    try {
        auto resp = t.get();
        return resp;
    } catch (...) {
        throw;
    }
});

Seite löschen

Parameter

Name	Type	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: DeletePageAPIResponse

Beispiel

deletePage Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t pageId = U("page-456");
boost::optional<utility::string_t> correlationId = boost::optional<utility::string_t>(U("corr-20251122"));
auto task = api->deletePage(tenantId, pageId)
    .then([correlationId](pplx::task<std::shared_ptr<DeletePageAPIResponse>> prev) -> std::shared_ptr<DeletePageAPIResponse> {
        try {
            auto resp = prev.get();
            if (resp) return resp;
            return std::make_shared<DeletePageAPIResponse>();
        } catch (const std::exception&) {
            return std::make_shared<DeletePageAPIResponse>();
        }
    });

Seite nach URL-ID abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
urlId	string	Ja

Antwort

Gibt zurück: GetPageByURLIdAPIResponse

Beispiel

getPageByURLId Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("home-page-789");
boost::optional<utility::string_t> locale = boost::optional<utility::string_t>(U("en-US"));
api->getPageByURLId(tenantId, urlId).then([=](pplx::task<std::shared_ptr<GetPageByURLIdAPIResponse>> task){
    try {
        auto resp = task.get();
        auto result = resp ? resp : std::make_shared<GetPageByURLIdAPIResponse>();
        (void)result;
    } catch (const std::exception &ex) {
        auto err = std::make_shared<GetPageByURLIdAPIResponse>();
        (void)err;
    }
});

Seiten abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja

Antwort

Gibt zurück: GetPagesAPIResponse

Beispiel

getPages Beispiel

Copy

int main()
{
    utility::string_t tenantId = U("my-tenant-123");
    boost::optional<utility::string_t> statusFilter = U("published");
    boost::optional<int> pageNumber = 1;
    auto placeholder = std::make_shared<GetPagesAPIResponse>();
    api->getPages(tenantId)
       .then([placeholder](std::shared_ptr<GetPagesAPIResponse> resp) {
           if (resp) {
               *placeholder = *resp;
               auto refs = resp.use_count();
               (void)refs;
           }
       })
       .wait();
    return 0;
}

Seite teilweise aktualisieren

Parameter

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

Antwort

Gibt zurück: PatchPageAPIResponse

Beispiel

patchPage Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t pageId = U("page-9876");
auto updatePtr = std::make_shared<UpdateAPIPageData>();
updatePtr->title = utility::string_t(U("About Our Team"));
updatePtr->slug = utility::string_t(U("about-our-team"));
updatePtr->enabled = boost::optional<bool>(true);
updatePtr->description = boost::optional<utility::string_t>(U("Updated team overview and contact information"));
api->patchPage(tenantId, pageId, *updatePtr)
.then([](pplx::task<std::shared_ptr<PatchPageAPIResponse>> t){
    try {
        auto resp = t.get();
        if (resp) {
            std::cout << "Patch successful, page id: " << resp->id << std::endl;
        }
    } catch (const std::exception &e) {
        std::cerr << "Patch failed: " << e.what() << std::endl;
    }
});

Ausstehendes Webhook-Ereignis löschen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

deletePendingWebhookEvent Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t eventId = U("wh_evt_456");
boost::optional<utility::string_t> requestId = boost::optional<utility::string_t>(U("req-789"));
api->deletePendingWebhookEvent(tenantId, eventId)
    .then([requestId](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
        try {
            auto resp = t.get();
            if (resp) {
                auto resultCopy = std::make_shared<FlagCommentPublic_200_response>(*resp);
                if (requestId) {
                    (void)requestId.get();
                }
                (void)resultCopy;
            } else {
                auto fallback = std::make_shared<FlagCommentPublic_200_response>();
                (void)fallback;
            }
        } catch (const std::exception&) {
            auto errorObj = std::make_shared<FlagCommentPublic_200_response>();
            (void)errorObj;
        }
    }).wait();

Anzahl ausstehender Webhook-Ereignisse abrufen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Nein
externalId	string	Nein
eventType	string	Nein
type	string	Nein
domain	string	Nein
attemptCountGT	double	Nein

Antwort

Gibt zurück: GetPendingWebhookEventCount_200_response

Beispiel

Beispiel für getPendingWebhookEventCount

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> commentId = boost::optional<utility::string_t>(U("cmt-789"));
boost::optional<utility::string_t> externalId = boost::optional<utility::string_t>(U("ext-456"));
boost::optional<utility::string_t> eventType = boost::optional<utility::string_t>(U("comment_created"));
boost::optional<utility::string_t> type = boost::optional<utility::string_t>(U("webhook"));
boost::optional<utility::string_t> domain = boost::optional<utility::string_t>(U("example.com"));
boost::optional<double> attemptCountGT = boost::optional<double>(1.0);
api->getPendingWebhookEventCount(tenantId, commentId, externalId, eventType, type, domain, attemptCountGT)
.then([](pplx::task<std::shared_ptr<GetPendingWebhookEventCount_200_response>> t){
    try {
        auto resp = t.get();
        auto respCopy = std::make_shared<GetPendingWebhookEventCount_200_response>(*resp);
        std::cout << "Pending webhook event count retrieved\n";
    } catch (const std::exception &e) {
        std::cerr << "Failed to get pending count: " << e.what() << '\n';
    }
}).wait();

Ausstehende Webhook-Ereignisse abrufen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Nein
externalId	string	Nein
eventType	string	Nein
type	string	Nein
domain	string	Nein
attemptCountGT	double	Nein
skip	double	Nein

Antwort

Gibt zurück: GetPendingWebhookEvents_200_response

Beispiel

getPendingWebhookEvents Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> commentId = boost::optional<utility::string_t>(U("cmt-98765"));
boost::optional<utility::string_t> externalId = boost::optional<utility::string_t>(U("ext-abc-01"));
boost::optional<utility::string_t> eventType = boost::optional<utility::string_t>(U("comment_created"));
boost::optional<utility::string_t> type = boost::optional<utility::string_t>(U("webhook"));
boost::optional<utility::string_t> domain = boost::optional<utility::string_t>(U("example.com"));
boost::optional<double> attemptCountGT = boost::optional<double>(2.0);
boost::optional<double> skip = boost::optional<double>(0.0);
api->getPendingWebhookEvents(tenantId, commentId, externalId, eventType, type, domain, attemptCountGT, skip)
.then([](pplx::task<std::shared_ptr<GetPendingWebhookEvents_200_response>> t) {
    try {
        auto resp = t.get();
        auto copy = std::make_shared<GetPendingWebhookEvents_200_response>(*resp);
        (void)copy;
    } catch (const std::exception& e) {
        (void)e;
        auto empty = std::make_shared<GetPendingWebhookEvents_200_response>();
        (void)empty;
    }
});

Fragekonfiguration erstellen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createQuestionConfigBody	CreateQuestionConfigBody	Ja

Antwort

Gibt zurück: CreateQuestionConfig_200_response

Beispiel

createQuestionConfig Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateQuestionConfigBody body;
body.name = utility::string_t(U("Feature X Feedback"));
body.description = boost::optional<utility::string_t>(utility::string_t(U("Ask users if Feature X met their needs")));
body.createdBy = utility::string_t(U("admin@mycompany.com"));
body.enabled = boost::optional<bool>(true);
api->createQuestionConfig(tenantId, body).then([](std::shared_ptr<CreateQuestionConfig_200_response> resp){
    if(resp){
        auto result = std::make_shared<CreateQuestionConfig_200_response>(*resp);
        std::wcout << U("Question config created successfully") << std::endl;
    } else {
        std::wcout << U("Failed to create question config") << std::endl;
    }
});

Fragekonfiguration löschen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

deleteQuestionConfig Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("qcfg-98765");
boost::optional<utility::string_t> tenantOpt = tenantId;
auto t = api->deleteQuestionConfig(tenantOpt.value_or(utility::string_t()), id)
.then([](std::shared_ptr<FlagCommentPublic_200_response> resp) -> std::shared_ptr<FlagCommentPublic_200_response> {
    auto out = std::make_shared<FlagCommentPublic_200_response>();
    if (resp) *out = *resp;
    return out;
});
t.wait();

Fragekonfiguration abrufen

Parameter

Name	Type	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: GetQuestionConfig_200_response

Beispiel

getQuestionConfig Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("question-456");
boost::optional<utility::string_t> locale = U("en-US");
auto defaultResp = std::make_shared<GetQuestionConfig_200_response>();
api->getQuestionConfig(tenantId, id).then([defaultResp](pplx::task<std::shared_ptr<GetQuestionConfig_200_response>> t) {
    try {
        auto resp = t.get();
        if(!resp) resp = defaultResp;
        std::cout << "Question config retrieved" << std::endl;
    } catch(const std::exception &e) {
        std::cerr << "Failed to get question config: " << e.what() << std::endl;
    }
});

Fragekonfigurationen abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
skip	double	Nein

Response

Rückgabe: GetQuestionConfigs_200_response

Beispiel

getQuestionConfigs Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = 10;
api->getQuestionConfigs(tenantId, skip).then([](pplx::task<std::shared_ptr<GetQuestionConfigs_200_response>> task) {
    try {
        auto resp = task.get();
        if (resp) {
            auto localCopy = std::make_shared<GetQuestionConfigs_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

Fragekonfiguration aktualisieren

Parameter

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

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

updateQuestionConfig Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto configId = utility::string_t(U("question-config-456"));
auto body = std::make_shared<UpdateQuestionConfigBody>();
body->enabled = true;
body->threshold = 5;
body->moderatorEmail = utility::string_t(U("moderator@example.com"));
body->notifyUsers = boost::optional<bool>(true);
body->description = boost::optional<utility::string_t>(utility::string_t(U("Tighten question moderation for new users")));
api->updateQuestionConfig(tenantId, configId, *body)
    .then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
        try {
            auto resp = t.get();
            std::cout << (resp ? "updateQuestionConfig succeeded\n" : "updateQuestionConfig returned null\n");
        } catch (const std::exception& e) {
            std::cerr << "updateQuestionConfig failed: " << e.what() << '\n';
        }
    });

Frageergebnis erstellen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createQuestionResultBody	CreateQuestionResultBody	Ja

Antwort

Gibt zurück: CreateQuestionResult_200_response

Beispiel

createQuestionResult Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateQuestionResultBody createQuestionResultBody;
createQuestionResultBody.questionId = U("question-789");
createQuestionResultBody.userEmail = U("student@example.com");
createQuestionResultBody.selectedOption = U("B");
createQuestionResultBody.isCorrect = true;
createQuestionResultBody.score = 9.5;
createQuestionResultBody.metadata = boost::optional<utility::string_t>(U("{\"session\":\"quiz-2026-01\"}"));
auto task = api->createQuestionResult(tenantId, createQuestionResultBody)
.then([](pplx::task<std::shared_ptr<CreateQuestionResult_200_response>> t){
    try {
        auto result = t.get();
        auto copy = std::make_shared<CreateQuestionResult_200_response>(*result);
        (void)copy;
    } catch (...) {}
});
task.wait();

Frageergebnis löschen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

deleteQuestionResult Beispiel

Copy

boost::optional<utility::string_t> maybeTenant = boost::none;
utility::string_t defaultTenant = U("my-tenant-123");
utility::string_t questionId = U("question-456");
utility::string_t tenant = maybeTenant ? *maybeTenant : defaultTenant;
api->deleteQuestionResult(tenant, questionId)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> task){
    try {
        auto resp = task.get();
        auto processed = std::make_shared<FlagCommentPublic_200_response>(*resp);
    } catch (const std::exception&) {
    }
});

Frageergebnis abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Response

Gibt zurück: GetQuestionResult_200_response

Beispiel

Beispiel für getQuestionResult

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t questionId = U("question-456");
boost::optional<utility::string_t> requestor = U("user@example.com");
auto task = api->getQuestionResult(tenantId, questionId)
    .then([requestor](pplx::task<std::shared_ptr<GetQuestionResult_200_response>> prev) -> std::shared_ptr<GetQuestionResult_200_response> {
        try {
            auto resp = prev.get();
            if (!resp) return std::make_shared<GetQuestionResult_200_response>();
            (void)requestor;
            return resp;
        } catch (const std::exception &) {
            return std::make_shared<GetQuestionResult_200_response>();
        }
    });

Frageergebnisse abrufen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
urlId	string	Nein
userId	string	Nein
startDate	string	Nein
questionId	string	Nein
questionIds	string	Nein
skip	double	Nein

Antwort

Gibt zurück: GetQuestionResults_200_response

Beispiel

getQuestionResults Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> urlId = boost::optional<utility::string_t>(U("/articles/2025/new-feature"));
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("alice@example.com"));
boost::optional<utility::string_t> startDate = boost::optional<utility::string_t>(U("2025-01-01T00:00:00Z"));
boost::optional<utility::string_t> questionId = boost::optional<utility::string_t>(U("q-789"));
boost::optional<utility::string_t> questionIds = boost::optional<utility::string_t>(U("q-789,q-790"));
boost::optional<double> skip = boost::optional<double>(10.0);
api->getQuestionResults(tenantId, urlId, userId, startDate, questionId, questionIds, skip)
.then([](pplx::task<std::shared_ptr<GetQuestionResults_200_response>> t){
    try {
        std::shared_ptr<GetQuestionResults_200_response> resp = t.get();
        if (resp) {
            auto copy = std::make_shared<GetQuestionResults_200_response>(*resp);
        }
    } catch (const std::exception&) {}
});

Frageergebnis aktualisieren

Parameter

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

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

updateQuestionResult Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("question-456");
UpdateQuestionResultBody updateQuestionResultBody;
auto moderatorEmail = std::make_shared<utility::string_t>(U("moderator@example.com"));
boost::optional<utility::string_t> resolutionNote = boost::optional<utility::string_t>(U("Marked duplicate of q-123"));
api->updateQuestionResult(tenantId, id, updateQuestionResultBody)
    .then([moderatorEmail, resolutionNote](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t)
    {
        try {
            auto resp = t.get();
            if (resp) {
                auto resultPtr = resp;
            }
        } catch (...) {}
    });

Frageergebnisse aggregieren

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
questionId	string	Nein
questionIds	vector<string	Nein
urlId	string	Nein
timeBucket	AggregateTimeBucket	Nein
startDate	datetime	Nein
forceRecalculate	bool	Nein

Antwort

Gibt zurück: AggregateQuestionResults_200_response

Beispiel

aggregateQuestionResults Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> questionId(U("q-42"));
boost::optional<std::vector<utility::string_t>> questionIds(std::vector<utility::string_t>{U("q-42"), U("q-43")});
boost::optional<utility::string_t> urlId(U("page-789"));
boost::optional<AggregateTimeBucket> timeBucket;
boost::optional<utility::datetime> startDate(utility::datetime::from_string(U("2025-01-01T00:00:00Z")));
boost::optional<bool> forceRecalculate(true);
api->aggregateQuestionResults(tenantId, questionId, questionIds, urlId, timeBucket, startDate, forceRecalculate)
.then([](std::shared_ptr<AggregateQuestionResults_200_response> resp){
    if (resp) {
        auto resultCopy = std::make_shared<AggregateQuestionResults_200_response>(*resp);
    }
});

Massenaggregation von Frageergebnissen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Ja
forceRecalculate	bool	Nein

Antwort

Gibt zurück: BulkAggregateQuestionResults_200_response

Beispiel

bulkAggregateQuestionResults Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
BulkAggregateQuestionResultsRequest request;
boost::optional<bool> forceRecalculate(true);
api->bulkAggregateQuestionResults(tenantId, request, forceRecalculate)
.then([](pplx::task<std::shared_ptr<BulkAggregateQuestionResults_200_response>> t){
    try {
        auto resp = t.get();
        if (!resp) {
            auto empty = std::make_shared<BulkAggregateQuestionResults_200_response>();
            std::cout << "No aggregated results returned\n";
        } else {
            std::cout << "Aggregated results received\n";
        }
    } catch (const std::exception& ex) {
        std::cerr << "Error fetching aggregated results: " << ex.what() << '\n';
    }
});

Kommentare mit Frageergebnissen kombinieren

Parameter

Name	Type	Erforderlich
tenantId	string	Ja
questionId	string	Nein
questionIds	vector<string	Nein
urlId	string	Nein
startDate	datetime	Nein
forceRecalculate	bool	Nein
minValue	double	Nein
maxValue	double	Nein
limit	double	Nein

Antwort

Gibt zurück: CombineCommentsWithQuestionResults_200_response

Beispiel

Beispiel für combineCommentsWithQuestionResults

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> questionId = boost::optional<utility::string_t>(U("q-98765"));
boost::optional<std::vector<utility::string_t>> questionIds = boost::optional<std::vector<utility::string_t>>(std::vector<utility::string_t>{U("q-98765"), U("q-12345")});
boost::optional<utility::string_t> urlId = boost::optional<utility::string_t>(U("/posts/2024/interesting-article"));
boost::optional<utility::datetime> startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2024-01-01T00:00:00Z")));
boost::optional<bool> forceRecalculate = boost::optional<bool>(true);
boost::optional<double> minValue = boost::optional<double>(0.0);
boost::optional<double> maxValue = boost::optional<double>(1.0);
boost::optional<double> limit = boost::optional<double>(100.0);
api->combineCommentsWithQuestionResults(tenantId, questionId, questionIds, urlId, startDate, forceRecalculate, minValue, maxValue, limit)
.then([](pplx::task<std::shared_ptr<CombineCommentsWithQuestionResults_200_response>> task){
    try {
        auto response = task.get();
        auto output = response ? response : std::make_shared<CombineCommentsWithQuestionResults_200_response>();
    } catch (const std::exception&) {
    }
});

SSO-Benutzer hinzufügen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createAPISSOUserData	CreateAPISSOUserData	Ja

Antwort

Gibt zurück: AddSSOUserAPIResponse

Beispiel

addSSOUser Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
auto createData = std::make_shared<CreateAPISSOUserData>();
createData->email = utility::string_t(U("alice@example.com"));
createData->externalUserId = utility::string_t(U("okta|987654321"));
createData->displayName = boost::optional<utility::string_t>(U("Alice Johnson"));
createData->roles = std::vector<utility::string_t>{ U("moderator"), U("editor") };
api->addSSOUser(tenantId, createData)
.then([](pplx::task<std::shared_ptr<AddSSOUserAPIResponse>> task){
    try {
        auto resp = task.get();
        if (resp) {
            (void)resp;
        }
    } catch (...) {
    }
});

SSO-Benutzer löschen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
deleteComments	bool	Nein
commentDeleteMode	string	Nein

Antwort

Gibt zurück: DeleteSSOUserAPIResponse

Beispiel

Beispiel für deleteSSOUser

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t ssoId = U("user@example.com");
boost::optional<bool> deleteComments = true;
boost::optional<utility::string_t> commentDeleteMode = U("anonymize");
api->deleteSSOUser(tenantId, ssoId, deleteComments, commentDeleteMode)
.then([](pplx::task<std::shared_ptr<DeleteSSOUserAPIResponse>> t){
    try {
        auto resp = t.get();
        auto respCopy = std::make_shared<DeleteSSOUserAPIResponse>(*resp);
        (void)respCopy;
    } catch (const std::exception&) {
    }
});

SSO-Benutzer per E-Mail abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
email	string	Ja

Antwort

Gibt zurück: GetSSOUserByEmailAPIResponse

Beispiel

getSSOUserByEmail Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t email = U("user@example.com");
boost::optional<utility::string_t> includeInactive = boost::optional<utility::string_t>(U("false"));
api->getSSOUserByEmail(tenantId, email).then([includeInactive](pplx::task<std::shared_ptr<GetSSOUserByEmailAPIResponse>> t) {
    try {
        auto resp = t.get();
        return resp ? resp : std::make_shared<GetSSOUserByEmailAPIResponse>();
    } catch (...) {
        return std::make_shared<GetSSOUserByEmailAPIResponse>();
    }
}).then([](std::shared_ptr<GetSSOUserByEmailAPIResponse> finalResp) {
    (void)finalResp;
});

SSO-Benutzer per ID abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: GetSSOUserByIdAPIResponse

Beispiel

getSSOUserById Beispiel

Copy

boost::optional<utility::string_t> optId = U("user-42@example.com");
utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = optId.value_or(U("user-42@example.com"));
api->getSSOUserById(tenantId, id).then([](pplx::task<std::shared_ptr<GetSSOUserByIdAPIResponse>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto out = resp;
            (void)out;
        } else {
            auto fallback = std::make_shared<GetSSOUserByIdAPIResponse>();
            (void)fallback;
        }
    } catch (const std::exception& ex) {
        auto fallback = std::make_shared<GetSSOUserByIdAPIResponse>();
        (void)ex;
        (void)fallback;
    }
});

SSO-Benutzer abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
skip	int32_t	Nein

Antwort

Gibt zurück: GetSSOUsers_200_response

Beispiel

getSSOUsers Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<int32_t> skip = 10;
api->getSSOUsers(tenantId, skip).then([](pplx::task<std::shared_ptr<GetSSOUsers_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<GetSSOUsers_200_response>(*resp);
        }
    } catch(...) {}
});

SSO-Benutzer teilweise aktualisieren

Parameter

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

Antwort

Gibt zurück: PatchSSOUserAPIResponse

Beispiel

patchSSOUser Beispiel

Copy

UpdateAPISSOUserData updateData;
updateData.email = utility::string_t(U"user@example.com");
updateData.displayName = utility::string_t(U"Jane Doe");
boost::optional<bool> updateComments = true;
auto responseHolder = std::make_shared<PatchSSOUserAPIResponse>();
api->patchSSOUser(utility::string_t(U"my-tenant-123"), utility::string_t(U"user@example.com"), updateData, updateComments)
.then([responseHolder](std::shared_ptr<PatchSSOUserAPIResponse> resp){
    if (resp) *responseHolder = *resp;
    return responseHolder;
});

SSO-Benutzer ersetzen

Parameter

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

Antwort

Gibt zurück: PutSSOUserAPIResponse

Beispiel

putSSOUser Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("user@example.com");
UpdateAPISSOUserData updateData;
updateData.displayName = U("Jane Doe");
updateData.email = U("user@example.com");
boost::optional<bool> updateComments = true;
api->putSSOUser(tenantId, id, updateData, updateComments)
.then([](std::shared_ptr<PutSSOUserAPIResponse> resp){
    if(!resp){ std::cout << "putSSOUser returned null\n"; return; }
    auto copy = std::make_shared<PutSSOUserAPIResponse>(*resp);
    std::cout << "SSO user updated successfully\n";
});

Abonnement erstellen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Ja

Antwort

Gibt zurück: CreateSubscriptionAPIResponse

Beispiel

createSubscription Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
auto payload = std::make_shared<CreateAPIUserSubscriptionData>();
payload->userEmail = U("user@example.com");
payload->planId = U("pro-monthly");
payload->couponCode = boost::optional<utility::string_t>(U("WELCOME10"));
payload->trialDays = boost::optional<int>(14);
payload->autoRenew = boost::optional<bool>(true);
api->createSubscription(tenantId, *payload).then([](std::shared_ptr<CreateSubscriptionAPIResponse> resp) {
    if (resp) std::cout << "Subscription created successfully" << std::endl;
    else std::cout << "Failed to create subscription" << std::endl;
});

Abonnement löschen

Parameter

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

Antwort

Gibt zurück: DeleteSubscriptionAPIResponse

Beispiel

Beispiel für deleteSubscription

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("subscription-987");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
auto defaultResp = std::make_shared<DeleteSubscriptionAPIResponse>();
api->deleteSubscription(tenantId, id, userId)
.then([defaultResp](pplx::task<std::shared_ptr<DeleteSubscriptionAPIResponse>> t){
    try {
        auto resp = t.get();
        if (!resp) resp = defaultResp;
        std::cout << "Delete completed\n";
    } catch (const std::exception &e) {
        std::cerr << "Delete failed: " << e.what() << '\n';
    }
});

Abonnements abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
userId	string	Nein

Antwort

Gibt zurück: GetSubscriptionsAPIResponse

Beispiel

getSubscriptions Beispiel

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> userId = utility::conversions::to_string_t("user@example.com");
api->getSubscriptions(tenantId, userId)
.then([](std::shared_ptr<GetSubscriptionsAPIResponse> resp){
    if(!resp) return;
    auto copy = std::make_shared<GetSubscriptionsAPIResponse>(*resp);
})
.wait();

Abonnement aktualisieren

Parameter

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

Antwort

Gibt zurück: UpdateSubscriptionAPIResponse

Beispiel

updateSubscription Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t subscriptionId = U("sub-456");
UpdateAPIUserSubscriptionData updateData{};
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user-789"));
api->updateSubscription(tenantId, subscriptionId, updateData, userId)
.then([](pplx::task<std::shared_ptr<UpdateSubscriptionAPIResponse>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<UpdateSubscriptionAPIResponse>(*resp);
        }
    } catch (const std::exception&) {}
}).wait();

Tägliche Nutzung des Mandanten abrufen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
yearNumber	double	Nein
monthNumber	double	Nein
dayNumber	double	Nein
skip	double	Nein

Antwort

Gibt zurück: GetTenantDailyUsages_200_response

Beispiel

getTenantDailyUsages Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> year = 2025;
boost::optional<double> month = 1;
auto placeholder = std::make_shared<GetTenantDailyUsages_200_response>();
api->getTenantDailyUsages(tenantId, year, month, boost::optional<double>(), boost::optional<double>())
.then([](pplx::task<std::shared_ptr<GetTenantDailyUsages_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) std::cout << "Received tenant daily usages\n";
        else std::cout << "No usage data\n";
    } catch (const std::exception &e) {
        std::cout << "Request error: " << e.what() << '\n';
    }
});

Mandantenpaket erstellen

Parameter

Name	Type	Erforderlich	Beschreibung
tenantId	string	Ja
createTenantPackageBody	CreateTenantPackageBody	Ja

Antwort

Gibt zurück: CreateTenantPackage_200_response

Beispiel

createTenantPackage Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
auto body = std::make_shared<CreateTenantPackageBody>();
body->name = U("Standard Package - 1k comments");
body->createdByEmail = U("admin@mycompany.com");
body->monthlyLimit = boost::optional<int>(1000);
body->notes = boost::optional<utility::string_t>(U("Onboarding promo"));
api->createTenantPackage(tenantId, *body)
.then([](pplx::task<std::shared_ptr<CreateTenantPackage_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            std::cout << "Package created: " << utility::conversions::to_utf8string(resp->packageId) << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << "Create failed: " << e.what() << std::endl;
    }
});

Mandantenpaket löschen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

deleteTenantPackage Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t pkgId = U("package-456");
boost::optional<utility::string_t> ifMatch = boost::optional<utility::string_t>(U("\"etag-789\""));
auto fallback = std::make_shared<FlagCommentPublic_200_response>();
auto task = api->deleteTenantPackage(tenantId, pkgId).then([fallback](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) return resp;
        return fallback;
    } catch (const std::exception&) {
        return fallback;
    }
});
task.wait();

Mandantenpaket abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: GetTenantPackage_200_response

Beispiel

getTenantPackage Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t packageId = U("pkg-456");
boost::optional<utility::string_t> requestTrace = U("trace-20260112-01");
api->getTenantPackage(tenantId, packageId)
.then([requestTrace](std::shared_ptr<GetTenantPackage_200_response> resp){
    auto result = resp ? resp : std::make_shared<GetTenantPackage_200_response>();
    if (requestTrace) { auto trace = *requestTrace; (void)trace; }
    return result;
})
.then([](std::shared_ptr<GetTenantPackage_200_response> finalResp){
    (void)finalResp;
});

Mandantenpakete abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
skip	double	Nein

Antwort

Gibt zurück: GetTenantPackages_200_response

Beispiel

getTenantPackages Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = 10.0;
auto task = api->getTenantPackages(tenantId, skip).then([](pplx::task<std::shared_ptr<GetTenantPackages_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            (void)resp;
        }
    } catch (const std::exception&) {
        auto fallback = std::make_shared<GetTenantPackages_200_response>();
        (void)fallback;
    }
});

Mandantenpaket ersetzen

Parameter

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

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

replaceTenantPackage Beispiel

Copy

utility::string_t tenantId = utility::string_t("my-tenant-123");
utility::string_t packageId = utility::string_t("pkg-456");
ReplaceTenantPackageBody body;
body.name = utility::string_t("Premium Plan");
body.planId = utility::string_t("premium_monthly");
body.seats = 25;
body.billingEmail = utility::string_t("billing@acme.com");
boost::optional<utility::string_t> notes = boost::optional<utility::string_t>(utility::string_t("Migrated subscription"));
body.notes = notes;
api->replaceTenantPackage(tenantId, packageId, body).then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> task){
    try{
        auto resp = task.get();
        if(resp){
            auto resultCopy = std::make_shared<FlagCommentPublic_200_response>(*resp);
        }
    } catch(const std::exception&){
    }
});

Mandantenpaket aktualisieren

Parameter

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

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

Beispiel für updateTenantPackage

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t packageId = U("pkg-456");
auto bodyPtr = std::make_shared<UpdateTenantPackageBody>();
bodyPtr->name = utility::string_t(U("Pro Monthly"));
bodyPtr->description = boost::optional<utility::string_t>(U("Monthly subscription for pro users"));
bodyPtr->enabled = boost::optional<bool>(true);
api->updateTenantPackage(tenantId, packageId, *bodyPtr)
.then([](std::shared_ptr<FlagCommentPublic_200_response> resp){
    std::cout << (resp ? "updateTenantPackage succeeded\n" : "updateTenantPackage returned null\n");
});

Mandantenbenutzer erstellen

Parameter

Name	Type	Erforderlich	Beschreibung
tenantId	string	Ja
createTenantUserBody	CreateTenantUserBody	Ja

Antwort

Gibt zurück: CreateTenantUser_200_response

Beispiel

createTenantUser Beispiel

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
CreateTenantUserBody createTenantUserBody;
createTenantUserBody.email = utility::conversions::to_string_t("new.user@company.com");
createTenantUserBody.displayName = boost::optional<utility::string_t>(utility::conversions::to_string_t("New User"));
api->createTenantUser(tenantId, createTenantUserBody)
    .then([](pplx::task<std::shared_ptr<CreateTenantUser_200_response>> task){
        try {
            auto resp = task.get();
            auto created = std::make_shared<CreateTenantUser_200_response>(*resp);
        } catch (const std::exception&) {
        }
    });

Mandantenbenutzer löschen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
deleteComments	string	Nein
commentDeleteMode	string	Nein

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

deleteTenantUser Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user@example.com");
boost::optional<utility::string_t> deleteComments = boost::optional<utility::string_t>(U("true"));
boost::optional<utility::string_t> commentDeleteMode = boost::optional<utility::string_t>(U("soft"));
auto fallback = std::make_shared<FlagCommentPublic_200_response>();
api->deleteTenantUser(tenantId, userId, deleteComments, commentDeleteMode)
.then([fallback](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
    try {
        auto resp = t.get();
        if (!resp) resp = fallback;
        std::cout << "deleteTenantUser completed\n";
    } catch (const std::exception &e) {
        std::cout << "deleteTenantUser failed: " << e.what() << "\n";
    }
}).wait();

Mandantenbenutzer abrufen

Parameter

Name	Type	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: GetTenantUser_200_response

Beispiel

Beispiel für getTenantUser

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("alice@example.com");
boost::optional<utility::string_t> includeMetadata = boost::optional<utility::string_t>(U("true"));
api->getTenantUser(tenantId, userId).then([includeMetadata](pplx::task<std::shared_ptr<GetTenantUser_200_response>> t)
{
    try {
        auto resp = t.get();
        auto result = resp ? resp : std::make_shared<GetTenantUser_200_response>();
        if (includeMetadata && result) { (void)includeMetadata; }
        (void)result;
    } catch (const std::exception& e) {
        auto fallback = std::make_shared<GetTenantUser_200_response>();
        (void)fallback;
    }
});

Mandantenbenutzer abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
skip	double	Nein

Antwort

Gibt zurück: GetTenantUsers_200_response

Beispiel

getTenantUsers Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = boost::optional<double>(20);
api->getTenantUsers(tenantId, skip)
    .then([=](pplx::task<std::shared_ptr<GetTenantUsers_200_response>> t) {
        try {
            std::shared_ptr<GetTenantUsers_200_response> resp = t.get();
            if (!resp) resp = std::make_shared<GetTenantUsers_200_response>();
            (void)resp;
        } catch (const std::exception& ex) {
            (void)ex;
            std::shared_ptr<GetTenantUsers_200_response> err = std::make_shared<GetTenantUsers_200_response>();
        }
    });

Mandantenbenutzer ersetzen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
replaceTenantUserBody	ReplaceTenantUserBody	Ja
updateComments	string	Nein

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

replaceTenantUser Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("user@example.com");
ReplaceTenantUserBody replaceBody;
boost::optional<utility::string_t> updateComments = boost::optional<utility::string_t>(U("true"));
api->replaceTenantUser(tenantId, id, replaceBody, updateComments)
.then([](std::shared_ptr<FlagCommentPublic_200_response> resp){
    if (resp) {
        auto copy = std::make_shared<FlagCommentPublic_200_response>(*resp);
    }
});

Login-Link senden

Parameter

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

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

sendLoginLink Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user@example.com");
boost::optional<utility::string_t> redirectURL = utility::string_t(U("https://app.example.com/welcome"));
api->sendLoginLink(tenantId, userId, redirectURL)
    .then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t)
    {
        try
        {
            auto resp = t.get();
            if (resp) return resp;
            return std::make_shared<FlagCommentPublic_200_response>();
        }
        catch (...)
        {
            return std::make_shared<FlagCommentPublic_200_response>();
        }
    });

Mandantenbenutzer aktualisieren

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
updateTenantUserBody	UpdateTenantUserBody	Ja
updateComments	string	Nein

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

Beispiel für updateTenantUser

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("jane.doe@example.com");
auto bodyPtr = std::make_shared<UpdateTenantUserBody>();
bodyPtr->setEmail(U("jane.doe@example.com"));
bodyPtr->setDisplayName(U("Jane Doe"));
boost::optional<utility::string_t> updateComments = U("Normalized display name");
api->updateTenantUser(tenantId, userId, *bodyPtr, updateComments)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) std::cout << "Tenant user updated successfully\n";
        else std::cout << "Update returned no data\n";
    } catch (const std::exception& ex) {
        std::cerr << "Update failed: " << ex.what() << '\n';
    }
});

Mandanten erstellen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createTenantBody	CreateTenantBody	Ja

Antwort

Gibt zurück: CreateTenant_200_response

Beispiel

Beispiel für createTenant

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateTenantBody createTenantBody;
createTenantBody.displayName = U("My Tenant Inc");
createTenantBody.adminEmail = U("admin@mytenant.com");
createTenantBody.plan = boost::optional<utility::string_t>(U("pro"));
auto task = api->createTenant(tenantId, createTenantBody)
    .then([](std::shared_ptr<CreateTenant_200_response> resp){
        if (resp){
            auto createdId = std::make_shared<utility::string_t>(resp->tenantId);
        }
    });
task.wait();

Mandanten löschen

Parameter

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

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

deleteTenant Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("flag-456");
boost::optional<utility::string_t> sure = utility::string_t(U("true"));
api->deleteTenant(tenantId, id, sure)
    .then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
        try {
            auto resp = t.get();
            auto safeResp = resp ? resp : std::make_shared<FlagCommentPublic_200_response>();
            (void)safeResp;
        } catch (...) {}
    });

Mandanten abrufen

Parameter

Name	Type	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: GetTenant_200_response

Beispiel

getTenant Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("admin@fastcomments.com");
boost::optional<utility::string_t> asOf = boost::optional<utility::string_t>(U("2026-01-01T00:00:00Z"));
api->getTenant(tenantId, id).then([asOf](pplx::task<std::shared_ptr<GetTenant_200_response>> t) {
    try {
        auto resp = t.get();
        if (!resp) return;
        auto processed = std::make_shared<GetTenant_200_response>(*resp);
    } catch (const std::exception&) {
    }
});

Mandanten abrufen

Parameter

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

Antwort

Gibt zurück: GetTenants_200_response

Beispiel

getTenants Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> meta = boost::optional<utility::string_t>(U("admin@example.com"));
boost::optional<double> skip = boost::optional<double>(10.0);
auto task = api->getTenants(tenantId, meta, skip)
    .then([](std::shared_ptr<GetTenants_200_response> resp){
        if (resp) {
            auto copy = std::make_shared<GetTenants_200_response>(*resp);
        }
    });

Mandanten aktualisieren

Parameter

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

Antwort

Gibt zurück: FlagCommentPublic_200_response

Beispiel

updateTenant Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto id = utility::string_t(U("tenant-0001"));
auto bodyPtr = std::make_shared<UpdateTenantBody>();
bodyPtr->setDisplayName(utility::string_t(U("Acme Corporation")));
bodyPtr->setAdminEmail(utility::string_t(U("admin@acme.com")));
bodyPtr->setIsActive(true);
bodyPtr->setMaxUsers(boost::optional<int>(250));
api->updateTenant(tenantId, id, *bodyPtr)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto msg = resp->getMessage();
            std::wcout << msg << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
});

Ticketstatus ändern

Parameter

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

Response

Gibt zurück: ChangeTicketState_200_response

Beispiel

Beispiel für changeTicketState

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("agent@example.com");
utility::string_t id = U("TICKET-456");
auto changeBody = std::make_shared<ChangeTicketStateBody>();
changeBody->state = U("resolved");
changeBody->comment = U("Resolved as duplicate after review");
changeBody->notify = boost::optional<bool>(true);
api->changeTicketState(tenantId, userId, id, *changeBody)
.then([](pplx::task<std::shared_ptr<ChangeTicketState_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<ChangeTicketState_200_response>(*resp);
        }
    } catch (const std::exception&) {}
});

Ticket erstellen

Parameter

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

Antwort

Gibt zurück: CreateTicket_200_response

Beispiel

createTicket Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user@example.com");
auto bodyPtr = std::make_shared<CreateTicketBody>();
bodyPtr->subject = U("Comments not posting on article");
bodyPtr->message = U("Submitting a comment returns 200 but it does not appear for other users");
bodyPtr->priority = boost::optional<utility::string_t>(U("low"));
api->createTicket(tenantId, userId, *bodyPtr)
.then([](pplx::task<std::shared_ptr<CreateTicket_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto created = resp;
        }
    } catch (const std::exception& e) {
        (void)e;
    }
});

Ticket abrufen

Parameter

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

Antwort

Gibt zurück: GetTicket_200_response

Beispiel

getTicket-Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t ticketId = U("ticket-456");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
api->getTicket(tenantId, ticketId, userId)
.then([](pplx::task<std::shared_ptr<GetTicket_200_response>> t) {
    try {
        auto resp = t.get();
        auto wrapped = std::make_shared<std::shared_ptr<GetTicket_200_response>>(resp);
        if (*wrapped) {
            std::cout << "Ticket retrieved\n";
        } else {
            std::cout << "No ticket\n";
        }
    } catch (const std::exception &e) {
        std::cerr << "Error: " << e.what() << '\n';
    }
});

Tickets abrufen

Parameter

Name	Type	Erforderlich
tenantId	string	Ja
userId	string	Nein
state	double	Nein
skip	double	Nein
limit	double	Nein

Antwort

Gibt zurück: GetTickets_200_response

Beispiel

getTickets Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<double> state = boost::optional<double>(1.0);
boost::optional<double> skip = boost::optional<double>(0.0);
boost::optional<double> limit = boost::optional<double>(50.0);
api->getTickets(tenantId, userId, state, skip, limit)
.then([](pplx::task<std::shared_ptr<GetTickets_200_response>> t){
    try {
        auto resp = t.get();
        auto copy = std::make_shared<GetTickets_200_response>(*resp);
        std::cout << "Retrieved tickets: " << (resp ? "non-null" : "null") << std::endl;
    } catch (const std::exception &e) {
        std::cerr << "getTickets failed: " << e.what() << std::endl;
    }
});

Bild hochladen

Bild hochladen und skalieren

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
file	HttpContent	Yes
sizePreset	SizePreset	No
urlId	string	No

Antwort

Gibt zurück: UploadImageResponse

Beispiel

uploadImage Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
auto fileBytes = std::vector<unsigned char>{0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A};
auto file = std::make_shared<HttpContent>(fileBytes, U("image/png"), U("avatar.png"));
boost::optional<SizePreset> sizePreset = boost::optional<SizePreset>(SizePreset::MEDIUM);
boost::optional<utility::string_t> urlId = boost::optional<utility::string_t>(U("user-avatar-987"));
api->uploadImage(tenantId, file, sizePreset, urlId)
    .then([](pplx::task<std::shared_ptr<UploadImageResponse>> task) {
        try {
            return task.get();
        } catch (...) {
            return std::shared_ptr<UploadImageResponse>();
        }
    });

Fortschritt des Benutzerabzeichens nach ID abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: GetUserBadgeProgressById_200_response

Beispiel

getUserBadgeProgressById Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("badge-abc-456");
boost::optional<utility::string_t> preferredLocale = boost::optional<utility::string_t>(U("en-US"));
api->getUserBadgeProgressById(tenantId, id)
.then([=](std::shared_ptr<GetUserBadgeProgressById_200_response> resp){
    if(!resp) return;
    auto copy = std::make_shared<GetUserBadgeProgressById_200_response>(*resp);
    (void)copy;
});

Fortschritt des Benutzerabzeichens nach Benutzer-ID abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
userId	string	Ja

Antwort

Gibt zurück: GetUserBadgeProgressById_200_response

Beispiel

Beispiel für getUserBadgeProgressByUserId

Copy

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

Liste des Fortschritts der Benutzerabzeichen abrufen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
userId	string	Nein
limit	double	Nein
skip	double	Nein

Response

Gibt zurück: GetUserBadgeProgressList_200_response

Beispiel

getUserBadgeProgressList Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<double> limit = boost::optional<double>(50);
boost::optional<double> skip = boost::optional<double>(0);
api->getUserBadgeProgressList(tenantId, userId, limit, skip)
.then([](pplx::task<std::shared_ptr<GetUserBadgeProgressList_200_response>> t){
    try {
        auto resp = t.get();
        auto copied = std::make_shared<GetUserBadgeProgressList_200_response>(*resp);
        std::cout << "Badge progress entries received\n";
    } catch (const std::exception &e) {
        std::cerr << "Failed to get badge progress: " << e.what() << '\n';
    }
});

Benutzerabzeichen erstellen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createUserBadgeParams	CreateUserBadgeParams	Ja

Antwort

Gibt zurück: CreateUserBadge_200_response

Beispiel

createUserBadge Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateUserBadgeParams params;
params.userId = U("user@example.com");
params.badgeId = U("trusted-contributor");
params.note = boost::optional<utility::string_t>(U("Awarded for outstanding moderation"));
api->createUserBadge(tenantId, params)
.then([](std::shared_ptr<CreateUserBadge_200_response> resp){
    if (resp) {
        auto copied = std::make_shared<CreateUserBadge_200_response>(*resp);
    }
})
.wait();

Benutzerabzeichen löschen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: UpdateUserBadge_200_response

Beispiel

deleteUserBadge Beispiel

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
utility::string_t badgeId = utility::conversions::to_string_t("badge-456");
boost::optional<utility::string_t> traceId = boost::none;
api->deleteUserBadge(tenantId, badgeId)
.then([traceId](pplx::task<std::shared_ptr<UpdateUserBadge_200_response>> t) {
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<UpdateUserBadge_200_response>();
        return resp;
    } catch (const std::exception&) {
        return std::shared_ptr<UpdateUserBadge_200_response>();
    }
});

Benutzerabzeichen abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: GetUserBadge_200_response

Beispiel

getUserBadge Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("user@example.com");
boost::optional<utility::string_t> traceId = U("trace-456");
api->getUserBadge(tenantId, id).then([traceId](std::shared_ptr<GetUserBadge_200_response> resp) {
    if (!resp) resp = std::make_shared<GetUserBadge_200_response>();
    utility::string_t activeTrace = traceId.value_or(U(""));
    (void)activeTrace;
    return resp;
});

Benutzerabzeichen abrufen

Parameter

Name	Type	Erforderlich
tenantId	string	Ja
userId	string	Nein
badgeId	string	Nein
type	double	Nein
displayedOnComments	bool	Nein
limit	double	Nein
skip	double	Nein

Antwort

Gibt zurück: GetUserBadges_200_response

Beispiel

getUserBadges Beispiel

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> userId(utility::conversions::to_string_t("user@example.com"));
boost::optional<utility::string_t> badgeId(utility::conversions::to_string_t("badge-elite"));
boost::optional<double> type(1.0);
boost::optional<bool> displayedOnComments(true);
boost::optional<double> limit(50.0);
boost::optional<double> skip(0.0);
auto resultHolder = std::make_shared<GetUserBadges_200_response>();
api->getUserBadges(tenantId, userId, badgeId, type, displayedOnComments, limit, skip)
.then([&resultHolder](std::shared_ptr<GetUserBadges_200_response> resp){
    if (resp) resultHolder = resp;
    return resultHolder;
});

Benutzerabzeichen aktualisieren

Parameter

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

Antwort

Gibt zurück: UpdateUserBadge_200_response

Beispiel

Beispiel für updateUserBadge

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("user@example.com");
UpdateUserBadgeParams updateParams;
updateParams.badgeId = U("badge-top-100");
updateParams.label = U("Top Contributor");
updateParams.active = boost::optional<bool>(true);
updateParams.expiresAt = boost::optional<utility::string_t>(U("2026-12-31T23:59:59Z"));
api->updateUserBadge(tenantId, id, updateParams)
.then([](pplx::task<std::shared_ptr<UpdateUserBadge_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto result = std::make_shared<UpdateUserBadge_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

Benutzer-Benachrichtigungsanzahl abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
sso	string	Nein

Antwort

Gibt zurück: GetUserNotificationCount_200_response

Beispiel

getUserNotificationCount Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
std::shared_ptr<GetUserNotificationCount_200_response> result;
api->getUserNotificationCount(tenantId, sso)
.then([&result](pplx::task<std::shared_ptr<GetUserNotificationCount_200_response>> t) {
    try {
        result = t.get();
        if (!result) result = std::make_shared<GetUserNotificationCount_200_response>();
    } catch (...) {
        result = std::make_shared<GetUserNotificationCount_200_response>();
    }
}).wait();

Benutzerbenachrichtigungen abrufen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
pageSize	int32_t	Nein
afterId	string	Nein
includeContext	bool	Nein
afterCreatedAt	int64_t	Nein
unreadOnly	bool	Nein
dmOnly	bool	Nein
noDm	bool	Nein
includeTranslations	bool	Nein
sso	string	Nein

Antwort

Gibt zurück: GetUserNotifications_200_response

Beispiel

getUserNotifications Beispiel

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<int32_t> pageSize = 50;
boost::optional<utility::string_t> afterId = utility::conversions::to_string_t("notif_98765");
boost::optional<bool> includeContext = true;
boost::optional<int64_t> afterCreatedAt = static_cast<int64_t>(1672531200);
boost::optional<bool> unreadOnly = true;
boost::optional<bool> dmOnly = false;
boost::optional<bool> noDm = false;
boost::optional<bool> includeTranslations = true;
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("user@example.com");
api->getUserNotifications(tenantId, pageSize, afterId, includeContext, afterCreatedAt, unreadOnly, dmOnly, noDm, includeTranslations, sso)
.then([](pplx::task<std::shared_ptr<GetUserNotifications_200_response>> task){
    try {
        auto resp = task.get();
        auto copy = std::make_shared<GetUserNotifications_200_response>(*resp);
        return copy;
    } catch (...) {
        return std::shared_ptr<GetUserNotifications_200_response>();
    }
});

Benutzer-Benachrichtigungsanzahl zurücksetzen

Parameter

Name	Type	Erforderlich	Beschreibung
tenantId	string	Ja
sso	string	Nein

Antwort

Gibt zurück: ResetUserNotifications_200_response

Beispiel

Beispiel für resetUserNotificationCount

Copy

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

Benutzerbenachrichtigungen zurücksetzen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
afterId	string	Nein
afterCreatedAt	int64_t	Nein
unreadOnly	bool	Nein
dmOnly	bool	Nein
noDm	bool	Nein
sso	string	Nein

Antwort

Gibt zurück: ResetUserNotifications_200_response

Beispiel

resetUserNotifications Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> afterId = boost::optional<utility::string_t>(U("notif-987654321"));
boost::optional<int64_t> afterCreatedAt = boost::optional<int64_t>(1625097600000LL);
boost::optional<bool> unreadOnly = boost::optional<bool>(true);
boost::optional<bool> dmOnly = boost::optional<bool>(false);
boost::optional<bool> noDm;
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
api->resetUserNotifications(tenantId, afterId, afterCreatedAt, unreadOnly, dmOnly, noDm, sso)
    .then([](pplx::task<std::shared_ptr<ResetUserNotifications_200_response>> t)
    {
        try
        {
            auto resp = t.get();
            auto respCopy = std::make_shared<ResetUserNotifications_200_response>(*resp);
            return respCopy;
        }
        catch (...)
        {
            return std::shared_ptr<ResetUserNotifications_200_response>();
        }
    });

Kommentar-Abonnementstatus des Benutzers aktualisieren

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

Parameter

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

Antwort

Gibt zurück: UpdateUserNotificationStatus_200_response

Beispiel

updateUserNotificationCommentSubscriptionStatus Beispiel

Copy

utility::string_t tenantId = utility::string_t(U("my-tenant-123"));
utility::string_t notificationId = utility::string_t(U("notif-789"));
utility::string_t optedInOrOut = utility::string_t(U("opted_in"));
utility::string_t commentId = utility::string_t(U("cmt-456"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(utility::string_t(U("user@example.com")));
api->updateUserNotificationCommentSubscriptionStatus(tenantId, notificationId, optedInOrOut, commentId, sso)
.then([](pplx::task<std::shared_ptr<UpdateUserNotificationStatus_200_response>> t){
    try {
        auto resp = t.get();
        auto result = resp ? resp : std::make_shared<UpdateUserNotificationStatus_200_response>();
    } catch (const std::exception&) {}
});

Seiten-Abonnementstatus des Benutzers aktualisieren

Benachrichtigungen für eine Seite aktivieren oder deaktivieren. Wenn Benutzer für eine Seite abonniert sind, werden Benachrichtigungen erstellt für neue Root-Kommentare 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

Gibt zurück: UpdateUserNotificationStatus_200_response

Beispiel

Beispiel für updateUserNotificationPageSubscriptionStatus

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("page-456");
utility::string_t url = U("https://www.example.com/articles/2026/new-feature");
utility::string_t pageTitle = U("New Feature Announcement");
utility::string_t subscribedOrUnsubscribed = U("subscribed");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
auto placeholder = std::make_shared<UpdateUserNotificationStatus_200_response>();
api->updateUserNotificationPageSubscriptionStatus(tenantId, urlId, url, pageTitle, subscribedOrUnsubscribed, sso)
.then([](pplx::task<std::shared_ptr<UpdateUserNotificationStatus_200_response>> task){
    try {
        auto resp = task.get();
        (void)resp;
    } catch (const std::exception &e) {
        (void)e;
    }
});

Benachrichtigungsstatus des Benutzers aktualisieren

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
notificationId	string	Ja
newStatus	string	Ja
sso	string	Nein

Antwort

Rückgabe: UpdateUserNotificationStatus_200_response

Beispiel

Beispiel für updateUserNotificationStatus

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t notificationId = U("notification-789");
utility::string_t newStatus = U("read");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-token-abc123"));
api->updateUserNotificationStatus(tenantId, notificationId, newStatus, sso)
.then([](pplx::task<std::shared_ptr<UpdateUserNotificationStatus_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto result = std::make_shared<UpdateUserNotificationStatus_200_response>(*resp);
        }
    } catch (...) {
    }
});

Präsenzstatus der Benutzer abrufen

Parameter

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

Antwort

Gibt zurück: GetUserPresenceStatuses_200_response

Beispiel

getUserPresenceStatuses Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlIdWS = U("wss://realtime.fastcomments.com/socket/tenant-abc");
boost::optional<utility::string_t> optUserIds = U("alice@example.com,bob@example.com");
utility::string_t userIds = optUserIds.value_or(U("alice@example.com"));
auto task = api->getUserPresenceStatuses(tenantId, urlIdWS, userIds)
    .then([](std::shared_ptr<GetUserPresenceStatuses_200_response> resp) {
        if (!resp) return;
        auto copy = std::make_shared<GetUserPresenceStatuses_200_response>(*resp);
    });
task.wait();

Benutzer suchen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
urlId	string	Ja
usernameStartsWith	string	Nein
mentionGroupIds	vector<string	Nein
sso	string	Nein
searchSection	string	Nein

Antwort

Gibt zurück: SearchUsers_200_response

Beispiel

Beispiel für searchUsers

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("/articles/2026/fast-comments-integration");
boost::optional<utility::string_t> usernameStartsWith = boost::optional<utility::string_t>(U("alex"));
std::vector<utility::string_t> groupsVec = { U("editors"), U("contributors") };
boost::optional<std::vector<utility::string_t>> mentionGroupIds = boost::optional<std::vector<utility::string_t>>(groupsVec);
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-user-456"));
boost::optional<utility::string_t> searchSection = boost::optional<utility::string_t>(U("discussion"));
api->searchUsers(tenantId, urlId, usernameStartsWith, mentionGroupIds, sso, searchSection)
    .then([](pplx::task<std::shared_ptr<SearchUsers_200_response>> task) {
        try {
            auto resp = task.get();
            auto respCopy = std::make_shared<SearchUsers_200_response>(*resp);
            (void)respCopy;
        } catch (const std::exception&) {
        }
    });

Benutzer abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: GetUser_200_response

Beispiel

getUser Beispiel

Copy

boost::optional<utility::string_t> tenant(U("my-tenant-123"));
boost::optional<utility::string_t> userId(U("user@example.com"));
api->getUser(tenant.value(), userId.value())
    .then([](pplx::task<std::shared_ptr<GetUser_200_response>> task) {
        try {
            auto resp = task.get();
            if (resp) {
                auto result_copy = std::make_shared<GetUser_200_response>(*resp);
            } else {
                auto fallback = std::make_shared<GetUser_200_response>();
            }
        } catch (const std::exception &e) {
        }
    });

Abstimmung erstellen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
direction	string	Ja
userId	string	Nein
anonUserId	string	Nein

Antwort

Gibt zurück: VoteComment_200_response

Beispiel

createVote Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
utility::string_t direction = U("up");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
api->createVote(tenantId, commentId, direction, userId, boost::none)
.then([](pplx::task<std::shared_ptr<VoteComment_200_response>> task) {
    try {
        auto resp = task.get();
        if (!resp) resp = std::make_shared<VoteComment_200_response>();
    } catch (...) {}
});

Abstimmung löschen

Parameter

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

Antwort

Gibt zurück: DeleteCommentVote_200_response

Beispiel

deleteVote Beispiel

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
utility::string_t voteId = utility::conversions::to_string_t("vote-98765");
boost::optional<utility::string_t> editKey = boost::optional<utility::string_t>(utility::conversions::to_string_t("user-edit-key-abc123"));
api->deleteVote(tenantId, voteId, editKey)
.then([](pplx::task<std::shared_ptr<DeleteCommentVote_200_response>> t){
    try {
        auto resp = t.get();
        auto result = resp ? std::make_shared<DeleteCommentVote_200_response>(*resp)
                           : std::make_shared<DeleteCommentVote_200_response>();
        (void)result;
    } catch (const std::exception& e) {
        (void)e;
    }
});

Abstimmungen abrufen

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
urlId	string	Ja

Antwort

Gibt zurück: GetVotes_200_response

Beispiel

getVotes-Beispiel

Copy

boost::optional<utility::string_t> tenantId = utility::string_t(U("my-tenant-123"));
boost::optional<utility::string_t> urlId = utility::string_t(U("/posts/2025/new-features"));
auto task = api->getVotes(tenantId.value(), urlId.value()).then([](std::shared_ptr<GetVotes_200_response> resp){
    if (resp) {
        auto copy = std::make_shared<GetVotes_200_response>(*resp);
        std::cout << "Fetched votes successfully\n";
    } else {
        std::cout << "No votes response\n";
    }
});
task.wait();

Abstimmungen für Benutzer abrufen

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
urlId	string	Ja
userId	string	Nein
anonUserId	string	Nein

Antwort

Gibt zurück: GetVotesForUser_200_response

Beispiel

getVotesForUser Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("article-987");
boost::optional<utility::string_t> userId = utility::string_t(U("user@example.com"));
boost::optional<utility::string_t> anonUserId;
api->getVotesForUser(tenantId, urlId, userId, anonUserId)
.then([](pplx::task<std::shared_ptr<GetVotesForUser_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto copy = std::make_shared<GetVotesForUser_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

Benötigen Sie Hilfe?

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

Mitwirken

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

Sprache 🇩🇪 Deutsch

Dokumentation

Erste Schritte

API-Referenz

Verwendung

Aggregation

Audit-Protokolle

Vom Kommentar blockieren

Blockierte Kommentare prüfen

Kommentare

Domain-Konfigurationen

E-Mail-Vorlagen

Ereignisprotokoll

Feed-Beiträge

Kommentar melden

Hashtags

Moderatoren

Benachrichtigungsanzahl

Benachrichtigungen

Seiten

Ausstehende Webhook-Ereignisse

Fragekonfigurationen

Frageergebnisse

Aggregation der Frageergebnisse

SSO-Benutzer

Abonnements

Tägliche Nutzung des Mandanten

Mandantenpakete

Mandantenbenutzer

Mandanten

Tickets

Bild hochladen

Fortschritt der Benutzerabzeichen

Benutzerabzeichen

Benutzerbenachrichtigungen

Präsenzstatus der Benutzer

Benutzersuche

Benutzer

Abstimmungen

FastComments C++ SDK

Repository

Voraussetzungen

Installation

Abhängigkeiten installieren

Aus dem Quellcode bauen

Installation

Bibliotheksinhalt

Öffentliche vs. gesicherte APIs

Schnellstart

Authentifizierte APIs verwenden (DefaultAPI)

Öffentliche APIs verwenden (PublicAPI)

Häufige Probleme

API-Aufrufe: Synchron vs. Asynchron

Synchrone Aufrufe mit .get()

Asynchrone Aufrufe mit .then()

Entscheidung zwischen synchronen und asynchronen Aufrufen

Hinweise

Broadcast-IDs

SSO (Einmalanmeldung)

SSO-Verwendung

Einfaches SSO

Sicheres SSO

Dokumentation für fastcomments

Dokumentation der API-Endpunkte

Dokumentation der Modelle

Aggregieren

Parameter

Antwort

Beispiel

Audit-Protokolle abrufen

Parameter

Antwort

Beispiel

Öffentlich: Vom Kommentar blockieren

Parameter

Antwort

Beispiel

Öffentlich: Kommentar-Blockierung aufheben

Parameter

Antwort

Synchrone Aufrufe mit `.get()`

Asynchrone Aufrufe mit `.then()`