FastComments C++ SDK

Dit is de officiële C++ SDK voor FastComments.

Officiële C++ SDK voor de FastComments API

Repository

Vereisten

C++17 of nieuwer
CMake 3.14 of nieuwer
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (wordt automatisch gedownload voor tests)

Installatie

Installeer afhankelijkheden

sudo apt install libcpprest-dev libboost-all-dev

Bouwen vanuit bron

mkdir build
cd build
cmake ..
make

Installeren

sudo make install

Bibliotheekinhoud

Deze bibliotheek bevat de gegenereerde API-client en de SSO-hulpmiddelen om het werken met de API gemakkelijker te maken.

API Client Library Docs

Publieke versus beveiligde API's

Voor de API-client zijn er drie klassen, DefaultApi, PublicApi en ModerationApi. De DefaultApi bevat methoden die uw API-sleutel vereisen, en PublicApi bevat
methoden die rechtstreeks vanaf een browser/mobiel apparaat/etc. kunnen worden aangeroepen zonder authenticatie. De ModerationApi biedt een uitgebreide reeks van live en snelle moderatie-API's. Elke ModerationApi-methode accepteert een sso-parameter en kan authenticeren via SSO of een FastComments.com sessiecookie.

Snel aan de slag

Gebruik van geauthentiseerde API's (DefaultAPI)

Belangrijk:

U moet de basis-URL instellen (de cpp-restsdk-generator leest deze niet uit de OpenAPI-specificatie)
U moet uw API-sleutel op de ApiClient instellen voordat u geauthentiseerde verzoeken doet. Als u dat niet doet, zullen verzoeken mislukken met een 401-fout.

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

    // REQUIRED: Set the base URL (choose your 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

    // REQUIRED: Set your API key
    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);

    // Now make authenticated API calls
    return 0;
}

Gebruik van openbare API's (PublicAPI)

Openbare eindpunten vereisen geen authenticatie:

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

    // REQUIRED: Set the base URL
    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);

    // Make public API calls
    return 0;
}

Gebruik van moderatie-API's (ModerationApi)

De ModerationApi voedt het moderator-dashboard. Elke methode accepteert een sso-parameter zodat het aanroep wordt gedaan namens een SSO-geauthenticeerde moderator (zie de SSO-sectie hieronder voor hoe u een token maakt):

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

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

    // REQUIRED: Set the base URL
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

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

    // Pass the moderator's SSO token to authenticate the call
    auto ssoToken = utility::conversions::to_string_t("YOUR_MODERATOR_SSO_TOKEN");

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

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

    return 0;
}

Veelvoorkomende problemen

"URI must contain a hostname"-fout: Zorg ervoor dat u config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) aanroept vóór het maken van de ApiClient. De cpp-restsdk-generator leest de server-URL niet automatisch uit de OpenAPI-specificatie.
401 "missing-api-key"-fout: Zorg ervoor dat u config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) aanroept vóór het maken van de DefaultAPI-instantie.
Verkeerde API-klasse: Gebruik DefaultApi voor server-side geauthentificeerde verzoeken, PublicApi voor client-side/openbare verzoeken, en ModerationApi voor moderator-dashboard verzoeken (geauthentificeerd met een moderator SSO-token).

API-aanroepen uitvoeren: synchroon vs asynchroon

All API‑methoden in deze SDK retourneren pplx::task<std::shared_ptr<ResponseType>> vanuit de C++ REST SDK. Dit geeft je flexibiliteit in hoe je API‑reacties afhandelt.

Synchrone Aanroepen met `.get()`

Gebruik .get() om de aanroepende thread te blokkeren totdat het verzoek is voltooid en om het resultaat synchroon op te halen:

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

// Vereiste parameters zijn positioneel; optionele gaan in de optiestructuur
org::openapitools::client::api::GetCommentsOptions options;
options.urlId = utility::conversions::to_string_t("your-url-id");

// Roep .get() aan om te blokkeren en het resultaat synchroon op te halen
auto response = api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    options
).get();  // Blokkeert totdat het HTTP-verzoek is voltooid

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

Asynchrone Aanroepen met `.then()`

Gebruik .then() voor niet-blokkerende asynchrone uitvoering met callbacks:

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

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

// Vereiste parameters zijn positioneel; optionele gaan in de optiestructuur
org::openapitools::client::api::GetCommentsOptions options;
options.urlId = utility::conversions::to_string_t("your-url-id");

// Gebruik .then() voor asynchrone callback‑gebaseerde uitvoering
api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    options
).then([](std::shared_ptr<GetComments_200_response> response) {
    // Dit wordt asynchroon uitgevoerd wanneer het verzoek is voltooid
    if (response && response->comments) {
        std::cout << "Found " << response->comments->size() << " comments" << std::endl;
    }
});

// Uitvoering gaat onmiddellijk verder zonder te blokkeren
std::cout << "Request sent, continuing..." << std::endl;

Keuze tussen synchrone en asynchrone

De keuze hangt af van je runtime‑omgeving en applicatie‑architectuur:

.get() (Synchrone blokkering)

Blokkeert de aanroepende thread totdat het HTTP‑verzoek is voltooid
Eenvoudigere codeflow, makkelijker te begrijpen
Geschikt voor toegewijde werkerthreads, batchverwerking of opdrachtregeltools
Niet geschikt voor event loops, GUI‑threads of single‑threaded servers

.then() (Asynchrone niet‑blokkering)

Retourneert onmiddellijk, callback wordt uitgevoerd wanneer het verzoek is voltooid
Blokkeert de aanroepende thread niet
Vereist voor event‑gedreven architecturen, GUI‑toepassingen of single‑threaded event loops
Staat chaining van meerdere bewerkingen toe
Complexere controleflow

De testreeks van de SDK gebruikt uitsluitend .get(), maar dit is passend voor de testomgeving waar blokkeren acceptabel is.

Notities

Broadcast-id's

Je zult zien dat je in sommige API-aanroepen een broadcastId moet meegeven. Wanneer je gebeurtenissen ontvangt, krijg je dit ID terug, zodat je het evenement kunt negeren als je van plan bent wijzigingen optimistisch aan de client toe te passen (wat je waarschijnlijk wilt doen omdat het de beste ervaring biedt). Geef hier een UUID door. Het ID moet uniek genoeg zijn om niet twee keer in een browsersessie voor te komen.

SSO (Single Sign-On)

Zie hieronder voor SSO-voorbeelden.

SSO-gebruik

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

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

Documentatie voor fastcomments

Documentatie voor API-eindpunten

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

Klasse	Methode	HTTP-verzoek	Beschrijving
DefaultApi	addDomainConfig	POST /api/v1/domain-configs
DefaultApi	addHashTag	POST /api/v1/hash-tags
DefaultApi	addHashTagsBulk	POST /api/v1/hash-tags/bulk
DefaultApi	addPage	POST /api/v1/pages
DefaultApi	addSSOUser	POST /api/v1/sso-users
DefaultApi	aggregate	POST /api/v1/aggregate	Aggregates documenten door ze te groeperen (indien groupBy is opgegeven) en meerdere bewerkingen toe te passen. Verschillende bewerkingen (bijv. sum, countDistinct, avg, enz.) worden ondersteund.
DefaultApi	aggregateQuestionResults	GET /api/v1/question-results-aggregation
DefaultApi	blockUserFromComment	POST /api/v1/comments/{id}/block
DefaultApi	bulkAggregateQuestionResults	POST /api/v1/question-results-aggregation/bulk
DefaultApi	changeTicketState	PATCH /api/v1/tickets/{id}/state
DefaultApi	combineCommentsWithQuestionResults	GET /api/v1/question-results-aggregation/combine/comments
DefaultApi	createEmailTemplate	POST /api/v1/email-templates
DefaultApi	createFeedPost	POST /api/v1/feed-posts
DefaultApi	createModerator	POST /api/v1/moderators
DefaultApi	createQuestionConfig	POST /api/v1/question-configs
DefaultApi	createQuestionResult	POST /api/v1/question-results
DefaultApi	createSubscription	POST /api/v1/subscriptions
DefaultApi	createTenant	POST /api/v1/tenants
DefaultApi	createTenantPackage	POST /api/v1/tenant-packages
DefaultApi	createTenantUser	POST /api/v1/tenant-users
DefaultApi	createTicket	POST /api/v1/tickets
DefaultApi	createUserBadge	POST /api/v1/user-badges
DefaultApi	createVote	POST /api/v1/votes
DefaultApi	deleteComment	DELETE /api/v1/comments/{id}
DefaultApi	deleteDomainConfig	DELETE /api/v1/domain-configs/{domain}
DefaultApi	deleteEmailTemplate	DELETE /api/v1/email-templates/{id}
DefaultApi	deleteEmailTemplateRenderError	DELETE /api/v1/email-templates/{id}/render-errors/{errorId}
DefaultApi	deleteHashTag	DELETE /api/v1/hash-tags/{tag}
DefaultApi	deleteModerator	DELETE /api/v1/moderators/{id}
DefaultApi	deleteNotificationCount	DELETE /api/v1/notification-count/{id}
DefaultApi	deletePage	DELETE /api/v1/pages/{id}
DefaultApi	deletePendingWebhookEvent	DELETE /api/v1/pending-webhook-events/{id}
DefaultApi	deleteQuestionConfig	DELETE /api/v1/question-configs/{id}
DefaultApi	deleteQuestionResult	DELETE /api/v1/question-results/{id}
DefaultApi	deleteSSOUser	DELETE /api/v1/sso-users/{id}
DefaultApi	deleteSubscription	DELETE /api/v1/subscriptions/{id}
DefaultApi	deleteTenant	DELETE /api/v1/tenants/{id}
DefaultApi	deleteTenantPackage	DELETE /api/v1/tenant-packages/{id}
DefaultApi	deleteTenantUser	DELETE /api/v1/tenant-users/{id}
DefaultApi	deleteUserBadge	DELETE /api/v1/user-badges/{id}
DefaultApi	deleteVote	DELETE /api/v1/votes/{id}
DefaultApi	flagComment	POST /api/v1/comments/{id}/flag
DefaultApi	getAuditLogs	GET /api/v1/audit-logs
DefaultApi	getCachedNotificationCount	GET /api/v1/notification-count/{id}
DefaultApi	getComment	GET /api/v1/comments/{id}
DefaultApi	getComments	GET /api/v1/comments
DefaultApi	getDomainConfig	GET /api/v1/domain-configs/{domain}
DefaultApi	getDomainConfigs	GET /api/v1/domain-configs
DefaultApi	getEmailTemplate	GET /api/v1/email-templates/{id}
DefaultApi	getEmailTemplateDefinitions	GET /api/v1/email-templates/definitions
DefaultApi	getEmailTemplateRenderErrors	GET /api/v1/email-templates/{id}/render-errors
DefaultApi	getEmailTemplates	GET /api/v1/email-templates
DefaultApi	getFeedPosts	GET /api/v1/feed-posts	req tenantId afterId
DefaultApi	getHashTags	GET /api/v1/hash-tags
DefaultApi	getModerator	GET /api/v1/moderators/{id}
DefaultApi	getModerators	GET /api/v1/moderators
DefaultApi	getNotificationCount	GET /api/v1/notifications/count
DefaultApi	getNotifications	GET /api/v1/notifications
DefaultApi	getPageByURLId	GET /api/v1/pages/by-url-id
DefaultApi	getPages	GET /api/v1/pages
DefaultApi	getPendingWebhookEventCount	GET /api/v1/pending-webhook-events/count
DefaultApi	getPendingWebhookEvents	GET /api/v1/pending-webhook-events
DefaultApi	getQuestionConfig	GET /api/v1/question-configs/{id}
DefaultApi	getQuestionConfigs	GET /api/v1/question-configs
DefaultApi	getQuestionResult	GET /api/v1/question-results/{id}
DefaultApi	getQuestionResults	GET /api/v1/question-results
DefaultApi	getSSOUserByEmail	GET /api/v1/sso-users/by-email/{email}
DefaultApi	getSSOUserById	GET /api/v1/sso-users/by-id/{id}
DefaultApi	getSSOUsers	GET /api/v1/sso-users
DefaultApi	getSubscriptions	GET /api/v1/subscriptions
DefaultApi	getTenant	GET /api/v1/tenants/{id}
DefaultApi	getTenantDailyUsages	GET /api/v1/tenant-daily-usage
DefaultApi	getTenantPackage	GET /api/v1/tenant-packages/{id}
DefaultApi	getTenantPackages	GET /api/v1/tenant-packages
DefaultApi	getTenantUser	GET /api/v1/tenant-users/{id}
DefaultApi	getTenantUsers	GET /api/v1/tenant-users
DefaultApi	getTenants	GET /api/v1/tenants
DefaultApi	getTicket	GET /api/v1/tickets/{id}
DefaultApi	getTickets	GET /api/v1/tickets
DefaultApi	getUser	GET /api/v1/users/{id}
DefaultApi	getUserBadge	GET /api/v1/user-badges/{id}
DefaultApi	getUserBadgeProgressById	GET /api/v1/user-badge-progress/{id}
DefaultApi	getUserBadgeProgressByUserId	GET /api/v1/user-badge-progress/user/{userId}
DefaultApi	getUserBadgeProgressList	GET /api/v1/user-badge-progress
DefaultApi	getUserBadges	GET /api/v1/user-badges
DefaultApi	getVotes	GET /api/v1/votes
DefaultApi	getVotesForUser	GET /api/v1/votes/for-user
DefaultApi	patchDomainConfig	PATCH /api/v1/domain-configs/{domainToUpdate}
DefaultApi	patchHashTag	PATCH /api/v1/hash-tags/{tag}
DefaultApi	patchPage	PATCH /api/v1/pages/{id}
DefaultApi	patchSSOUser	PATCH /api/v1/sso-users/{id}
DefaultApi	putDomainConfig	PUT /api/v1/domain-configs/{domainToUpdate}
DefaultApi	putSSOUser	PUT /api/v1/sso-users/{id}
DefaultApi	renderEmailTemplate	POST /api/v1/email-templates/render
DefaultApi	replaceTenantPackage	PUT /api/v1/tenant-packages/{id}
DefaultApi	replaceTenantUser	PUT /api/v1/tenant-users/{id}
DefaultApi	saveComment	POST /api/v1/comments
DefaultApi	saveCommentsBulk	POST /api/v1/comments/bulk
DefaultApi	sendInvite	POST /api/v1/moderators/{id}/send-invite
DefaultApi	sendLoginLink	POST /api/v1/tenant-users/{id}/send-login-link
DefaultApi	unBlockUserFromComment	POST /api/v1/comments/{id}/un-block
DefaultApi	unFlagComment	POST /api/v1/comments/{id}/un-flag
DefaultApi	updateComment	PATCH /api/v1/comments/{id}
DefaultApi	updateEmailTemplate	PATCH /api/v1/email-templates/{id}
DefaultApi	updateFeedPost	PATCH /api/v1/feed-posts/{id}
DefaultApi	updateModerator	PATCH /api/v1/moderators/{id}
DefaultApi	updateNotification	PATCH /api/v1/notifications/{id}
DefaultApi	updateQuestionConfig	PATCH /api/v1/question-configs/{id}
DefaultApi	updateQuestionResult	PATCH /api/v1/question-results/{id}
DefaultApi	updateSubscription	PATCH /api/v1/subscriptions/{id}
DefaultApi	updateTenant	PATCH /api/v1/tenants/{id}
DefaultApi	updateTenantPackage	PATCH /api/v1/tenant-packages/{id}
DefaultApi	updateTenantUser	PATCH /api/v1/tenant-users/{id}
DefaultApi	updateUserBadge	PUT /api/v1/user-badges/{id}
ModerationApi	deleteModerationVote	DELETE /auth/my-account/moderate-comments/mod_api/vote/{commentId}/{voteId}
ModerationApi	getApiComments	GET /auth/my-account/moderate-comments/mod_api/api/comments
ModerationApi	getApiExportStatus	GET /auth/my-account/moderate-comments/mod_api/api/export/status
ModerationApi	getApiIds	GET /auth/my-account/moderate-comments/mod_api/api/ids
ModerationApi	getBanUsersFromComment	GET /auth/my-account/moderate-comments/mod_api/ban-users/from-comment/{commentId}
ModerationApi	getCommentBanStatus	GET /auth/my-account/moderate-comments/mod_api/get-comment-ban-status/{commentId}
ModerationApi	getCommentChildren	GET /auth/my-account/moderate-comments/mod_api/comment-children/{commentId}
ModerationApi	getCount	GET /auth/my-account/moderate-comments/mod_api/count
ModerationApi	getCounts	GET /auth/my-account/moderate-comments/banned-users/mod_api/counts
ModerationApi	getLogs	GET /auth/my-account/moderate-comments/mod_api/logs/{commentId}
ModerationApi	getManualBadges	GET /auth/my-account/moderate-comments/mod_api/get-manual-badges
ModerationApi	getManualBadgesForUser	GET /auth/my-account/moderate-comments/mod_api/get-manual-badges-for-user
ModerationApi	getModerationComment	GET /auth/my-account/moderate-comments/mod_api/comment/{commentId}
ModerationApi	getModerationCommentText	GET /auth/my-account/moderate-comments/mod_api/get-comment-text/{commentId}
ModerationApi	getPreBanSummary	GET /auth/my-account/moderate-comments/mod_api/pre-ban-summary/{commentId}
ModerationApi	getSearchCommentsSummary	GET /auth/my-account/moderate-comments/mod_api/search/comments/summary
ModerationApi	getSearchPages	GET /auth/my-account/moderate-comments/mod_api/search/pages
ModerationApi	getSearchSites	GET /auth/my-account/moderate-comments/mod_api/search/sites
ModerationApi	getSearchSuggest	GET /auth/my-account/moderate-comments/mod_api/search/suggest
ModerationApi	getSearchUsers	GET /auth/my-account/moderate-comments/mod_api/search/users
ModerationApi	getTrustFactor	GET /auth/my-account/moderate-comments/mod_api/get-trust-factor
ModerationApi	getUserBanPreference	GET /auth/my-account/moderate-comments/mod_api/user-ban-preference
ModerationApi	getUserInternalProfile	GET /auth/my-account/moderate-comments/mod_api/get-user-internal-profile
ModerationApi	postAdjustCommentVotes	POST /auth/my-account/moderate-comments/mod_api/adjust-comment-votes/{commentId}
ModerationApi	postApiExport	POST /auth/my-account/moderate-comments/mod_api/api/export
ModerationApi	postBanUserFromComment	POST /auth/my-account/moderate-comments/mod_api/ban-user/from-comment/{commentId}
ModerationApi	postBanUserUndo	POST /auth/my-account/moderate-comments/mod_api/ban-user/undo
ModerationApi	postBulkPreBanSummary	POST /auth/my-account/moderate-comments/mod_api/bulk-pre-ban-summary
ModerationApi	postCommentsByIds	POST /auth/my-account/moderate-comments/mod_api/comments-by-ids
ModerationApi	postFlagComment	POST /auth/my-account/moderate-comments/mod_api/flag-comment/{commentId}
ModerationApi	postRemoveComment	POST /auth/my-account/moderate-comments/mod_api/remove-comment/{commentId}
ModerationApi	postRestoreDeletedComment	POST /auth/my-account/moderate-comments/mod_api/restore-deleted-comment/{commentId}
ModerationApi	postSetCommentApprovalStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-approval-status/{commentId}
ModerationApi	postSetCommentReviewStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-review-status/{commentId}
ModerationApi	postSetCommentSpamStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-spam-status/{commentId}
ModerationApi	postSetCommentText	POST /auth/my-account/moderate-comments/mod_api/set-comment-text/{commentId}
ModerationApi	postUnFlagComment	POST /auth/my-account/moderate-comments/mod_api/un-flag-comment/{commentId}
ModerationApi	postVote	POST /auth/my-account/moderate-comments/mod_api/vote/{commentId}
ModerationApi	putAwardBadge	PUT /auth/my-account/moderate-comments/mod_api/award-badge
ModerationApi	putCloseThread	PUT /auth/my-account/moderate-comments/mod_api/close-thread
ModerationApi	putRemoveBadge	PUT /auth/my-account/moderate-comments/mod_api/remove-badge
ModerationApi	putReopenThread	PUT /auth/my-account/moderate-comments/mod_api/reopen-thread
ModerationApi	setTrustFactor	PUT /auth/my-account/moderate-comments/mod_api/set-trust-factor
PublicApi	blockFromCommentPublic	POST /block-from-comment/{commentId}
PublicApi	checkedCommentsForBlocked	GET /check-blocked-comments
PublicApi	createCommentPublic	POST /comments/{tenantId}
PublicApi	createFeedPostPublic	POST /feed-posts/{tenantId}
PublicApi	createV1PageReact	POST /page-reacts/v1/likes/{tenantId}
PublicApi	createV2PageReact	POST /page-reacts/v2/{tenantId}
PublicApi	deleteCommentPublic	DELETE /comments/{tenantId}/{commentId}
PublicApi	deleteCommentVote	DELETE /comments/{tenantId}/{commentId}/vote/{voteId}
PublicApi	deleteFeedPostPublic	DELETE /feed-posts/{tenantId}/{postId}
PublicApi	deleteV1PageReact	DELETE /page-reacts/v1/likes/{tenantId}
PublicApi	deleteV2PageReact	DELETE /page-reacts/v2/{tenantId}
PublicApi	flagCommentPublic	POST /flag-comment/{commentId}
PublicApi	getCommentText	GET /comments/{tenantId}/{commentId}/text
PublicApi	getCommentVoteUserNames	GET /comments/{tenantId}/{commentId}/votes
PublicApi	getCommentsForUser	GET /comments-for-user
PublicApi	getCommentsPublic	GET /comments/{tenantId}	req tenantId urlId
PublicApi	getEventLog	GET /event-log/{tenantId}	req tenantId urlId userIdWS
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	req tenantId afterId
PublicApi	getFeedPostsStats	GET /feed-posts/{tenantId}/stats
PublicApi	getGifLarge	GET /gifs/get-large/{tenantId}
PublicApi	getGifsSearch	GET /gifs/search/{tenantId}
PublicApi	getGifsTrending	GET /gifs/trending/{tenantId}
PublicApi	getGlobalEventLog	GET /event-log/global/{tenantId}	req tenantId urlId userIdWS
PublicApi	getOfflineUsers	GET /pages/{tenantId}/users/offline	Past commenters on the page who are NOT currently online. Sorted by displayName. Use this after exhausting /users/online to render a "Members" section. Cursor pagination on commenterName: server walks the partial {tenantId, urlId, commenterName} index from afterName forward via $gt, no $skip cost.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	Currently-online viewers of a page: people whose websocket session is subscribed to the page right now. Returns anonCount + totalCount (room-wide subscribers, including anon viewers we don't enumerate).
PublicApi	getPagesPublic	GET /pages/{tenantId}	List pages for a tenant. Used by the FChat desktop client to populate its room list. Requires `enableFChat` to be true on the resolved custom config for each page. Pages that require SSO are filtered against the requesting user's group access.
PublicApi	getTranslations	GET /translations/{namespace}/{component}
PublicApi	getUserNotificationCount	GET /user-notifications/get-count
PublicApi	getUserNotifications	GET /user-notifications
PublicApi	getUserPresenceStatuses	GET /user-presence-status
PublicApi	getUserReactsPublic	GET /feed-posts/{tenantId}/user-reacts
PublicApi	getUsersInfo	GET /pages/{tenantId}/users/info	Bulk user info for a tenant. Given userIds, return display info from User / SSOUser. Used by the comment widget to enrich users that just appeared via a presence event. No page context: privacy is enforced uniformly (private profiles are masked).
PublicApi	getV1PageLikes	GET /page-reacts/v1/likes/{tenantId}
PublicApi	getV2PageReactUsers	GET /page-reacts/v2/{tenantId}/list
PublicApi	getV2PageReacts	GET /page-reacts/v2/{tenantId}
PublicApi	lockComment	POST /comments/{tenantId}/{commentId}/lock
PublicApi	logoutPublic	PUT /auth/logout
PublicApi	pinComment	POST /comments/{tenantId}/{commentId}/pin
PublicApi	reactFeedPostPublic	POST /feed-posts/{tenantId}/react/{postId}
PublicApi	resetUserNotificationCount	POST /user-notifications/reset-count
PublicApi	resetUserNotifications	POST /user-notifications/reset
PublicApi	searchUsers	GET /user-search/{tenantId}
PublicApi	setCommentText	POST /comments/{tenantId}/{commentId}/update-text
PublicApi	unBlockCommentPublic	DELETE /block-from-comment/{commentId}
PublicApi	unLockComment	POST /comments/{tenantId}/{commentId}/unlock
PublicApi	unPinComment	POST /comments/{tenantId}/{commentId}/unpin
PublicApi	updateFeedPostPublic	PUT /feed-posts/{tenantId}/{postId}
PublicApi	updateUserNotificationCommentSubscriptionStatus	POST /user-notifications/{notificationId}/mark-opted/{optedInOrOut}	Schakel meldingen in of uit voor een specifiek commentaar.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Schakel meldingen in of uit voor een pagina. Wanneer gebruikers zich op een pagina abonneren, worden meldingen aangemaakt voor nieuwe root‑commentaren, en ook
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Upload en schaal een afbeelding
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Documentatie voor Modellen

aggregate

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

Parameters

Name	Type	Required
tenantId	string	Yes
aggregationRequest	AggregationRequest	Yes
options	const AggregateOptions&	Yes

Response

Returns: AggregateResponse

Voorbeeld

aggregatie Voorbeeld

Copy

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

getAuditLogs

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
options	const GetAuditLogsOptions&	Ja

Respons

Retourneert: GetAuditLogsResponse

Voorbeeld

getAuditLogs Voorbeeld

Copy

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

logoutPublic

Respons

Retourneert: APIEmptyResponse

Voorbeeld

logoutPublic Voorbeeld

Copy

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

blockFromCommentPublic

Parameters

Naam	Type	Vereist
tenantId	string	Ja
commentId	string	Ja
publicBlockFromCommentParams	PublicBlockFromCommentParams	Ja
sso	string	Nee

Respons

Retourneert: BlockSuccess

Voorbeeld

blockFromCommentPublic Voorbeeld

Copy

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

unBlockCommentPublic

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
commentId	string	Ja
publicBlockFromCommentParams	PublicBlockFromCommentParams	Ja
sso	string	Nee

Respons

Retourneert: UnblockSuccess

Voorbeeld

unBlockCommentPublic Voorbeeld

Copy

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

checkedCommentsForBlocked

Parameters

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

Respons

Retourneert: CheckBlockedCommentsResponse

Voorbeeld

checkedCommentsForBlocked voorbeeld

Copy

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

blockUserFromComment

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
blockFromCommentParams	BlockFromCommentParams	Yes
options	const BlockUserFromCommentOptions&	Yes

Respons

Retourneert: BlockSuccess

Voorbeeld

blockUserFromComment Voorbeeld

Copy

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

createCommentPublic

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
commentData	CommentData	Yes
options	const CreateCommentPublicOptions&	Yes

Response

Retourneert: SaveCommentsResponseWithPresence

Example

createCommentPublic Voorbeeld

Copy

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

deleteComment

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
id	string	Ja
options	const DeleteCommentOptions&	Ja

Respons

Retourneert: DeleteCommentResult

Voorbeeld

deleteComment Voorbeeld

Copy

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

deleteCommentPublic

Parameters

Naam	Type	Verplicht
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
options	const DeleteCommentPublicOptions&	Yes

Respons

Retourneert: PublicAPIDeleteCommentResponse

Voorbeeld

deleteCommentPublic Voorbeeld

Copy

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

deleteCommentVote

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
commentId	string	Ja
voteId	string	Ja
urlId	string	Ja
broadcastId	string	Ja
options	const DeleteCommentVoteOptions&	Ja

Response

Retourneert: VoteDeleteResponse

Voorbeeld

deleteCommentVote Voorbeeld

Copy

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

flagComment

Parameters

Naam	Type	Vereist
tenantId	string	Yes
id	string	Yes
options	const FlagCommentOptions&	Yes

Respons

Returns: FlagCommentResponse

Voorbeeld

flagComment Voorbeeld

Copy

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

getComment

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
id	string	Ja

Respons

Retourneert: APIGetCommentResponse

Voorbeeld

getComment Voorbeeld

Copy

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

getComments

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
options	const GetCommentsOptions&	Ja

Respons

Retourneert: APIGetCommentsResponse

Voorbeeld

getComments voorbeeld

Copy

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

getCommentsPublic

req tenantId urlId

Parameters

Naam	Type	Vereist
tenantId	string	Ja
urlId	string	Ja
options	const GetCommentsPublicOptions&	Ja

Respons

Retourneert: GetCommentsResponseWithPresence_PublicComment_

Voorbeeld

getCommentsPublic Voorbeeld

Copy

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

getCommentText

Parameters

Naam	Type	Vereist
tenantId	string	Ja
commentId	string	Ja
options	const GetCommentTextOptions&	Ja

Response

Retourneert: PublicAPIGetCommentTextResponse

Example

getCommentText Voorbeeld

Copy

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

getCommentVoteUserNames

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
commentId	string	Ja
dir	int32_t	Ja
sso	string	Nee

Respons

Retourneert: GetCommentVoteUserNamesSuccessResponse

Voorbeeld

getCommentVoteUserNames Voorbeeld

Copy

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

lockComment

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
commentId	string	Ja
broadcastId	string	Ja
sso	string	Nee

Respons

Retourneert: APIEmptyResponse

Voorbeeld

lockComment Voorbeeld

Copy

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

pinComment

Parameters

Naam	Type	Vereist
tenantId	string	Ja
commentId	string	Ja
broadcastId	string	Ja
sso	string	Nee

Response

Retourneert: ChangeCommentPinStatusResponse

Voorbeeld

pinComment Voorbeeld

Copy

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

saveComment

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
createCommentParams	CreateCommentParams	Ja
options	const SaveCommentOptions&	Ja

Response

Retourneert: APISaveCommentResponse

Voorbeeld

saveComment Voorbeeld

Copy

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

setCommentText

Parameters

Naam	Type	Vereist
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
commentTextUpdateRequest	CommentTextUpdateRequest	Yes
options	const SetCommentTextOptions&	Yes

Respons

Retourneert: PublicAPISetCommentTextResponse

Voorbeeld

setCommentText Voorbeeld

Copy

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

unBlockUserFromComment

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
id	string	Ja
unBlockFromCommentParams	UnBlockFromCommentParams	Ja
options	const UnBlockUserFromCommentOptions&	Ja

Response

Retourneert: UnblockSuccess

Voorbeeld

unBlockUserFromComment Voorbeeld

Copy

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

unFlagComment

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
id	string	Ja
options	const UnFlagCommentOptions&	Ja

Respons

Retourneert: FlagCommentResponse

Voorbeeld

unFlagComment voorbeeld

Copy

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

unLockComment

Parameters

Naam	Type	Vereist
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Respons

Retourneert: APIEmptyResponse

Voorbeeld

unLockComment Voorbeeld

Copy

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

unPinComment

Parameters

Naam	Type	Vereist
tenantId	string	Ja
commentId	string	Ja
broadcastId	string	Ja
sso	string	Nee

Respons

Retourneert: ChangeCommentPinStatusResponse

Voorbeeld

unPinComment Voorbeeld

Copy

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

updateComment

Parameters

Naam	Type	Vereist
tenantId	string	Ja
id	string	Ja
updatableCommentParams	UpdatableCommentParams	Ja
options	const UpdateCommentOptions&	Ja

Respons

Retourneert: APIEmptyResponse

Voorbeeld

updateComment Voorbeeld

Copy

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

voteComment

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
commentId	string	Ja
urlId	string	Ja
broadcastId	string	Ja
voteBodyParams	VoteBodyParams	Ja
options	const VoteCommentOptions&	Ja

Response

Retourneert: VoteResponse

Voorbeeld

voteComment Voorbeeld

Copy

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

getCommentsForUser

Parameters

Name	Type	Required	Description
options	const GetCommentsForUserOptions&	Yes

Respons

Retourneert: GetCommentsForUserResponse

Voorbeeld

getCommentsForUser Voorbeeld

Copy

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

addDomainConfig

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
addDomainConfigParams	AddDomainConfigParams	Ja

Respons

Retourneert: AddDomainConfigResponse

Voorbeeld

addDomainConfig Voorbeeld

Copy

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

deleteDomainConfig

Parameters

Name	Type	Required	Description
tenantId	string	Yes
domain	string	Yes

Respons

Retourneert: DeleteDomainConfigResponse

Voorbeeld

deleteDomainConfig Voorbeeld

Copy

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

getDomainConfig

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
domain	string	Ja

Respons

Retourneert: GetDomainConfigResponse

Voorbeeld

getDomainConfig Voorbeeld

Copy

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

getDomainConfigs

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja

Respons

Retourneert: GetDomainConfigsResponse

Voorbeeld

getDomainConfigs Voorbeeld

Copy

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

patchDomainConfig

Parameters

Name	Type	Required
tenantId	string	Yes
domainToUpdate	string	Yes
patchDomainConfigParams	PatchDomainConfigParams	Yes

Respons

Retourneert: PatchDomainConfigResponse

Voorbeeld

patchDomainConfig Voorbeeld

Copy

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

putDomainConfig

Parameters

Naam	Type	Vereist
tenantId	string	Yes
domainToUpdate	string	Yes
updateDomainConfigParams	UpdateDomainConfigParams	Yes

Respons

Retourneert: PutDomainConfigResponse

Voorbeeld

putDomainConfig Voorbeeld

Copy

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

createEmailTemplate

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
createEmailTemplateBody	CreateEmailTemplateBody	Ja

Respons

Retourneert: CreateEmailTemplateResponse

Voorbeeld

createEmailTemplate Voorbeeld

Copy

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

deleteEmailTemplate

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
id	string	Ja

Response

Retourneert: APIEmptyResponse

Voorbeeld

deleteEmailTemplate Voorbeeld

Copy

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

deleteEmailTemplateRenderError

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
id	string	Ja
errorId	string	Ja

Response

Retourneert: APIEmptyResponse

Example

deleteEmailTemplateRenderError Voorbeeld

Copy

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

getEmailTemplate

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Retourneert: GetEmailTemplateResponse

Example

Voorbeeld getEmailTemplate

Copy

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

getEmailTemplateDefinitions

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja

Respons

Retourneert: GetEmailTemplateDefinitionsResponse

Voorbeeld

getEmailTemplateDefinitions Voorbeeld

Copy

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

getEmailTemplateRenderErrors

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
id	string	Ja
skip	double	Nee

Respons

Retourneert: GetEmailTemplateRenderErrorsResponse

Example

getEmailTemplateRenderErrors Voorbeeld

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("email-template-789");
boost::optional<double> skip = 20.0;
api->getEmailTemplateRenderErrors(tenantId, id, skip)
    .then([](pplx::task<std::shared_ptr<GetEmailTemplateRenderErrorsResponse>> task) {
        try {
            auto response = task.get();
            // Gebruik respons naar behoefte
        } catch (const std::exception& ex) {
            // Verwerk fout
        }
    });

getEmailTemplates

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
skip	double	Nee

Response

Retour: GetEmailTemplatesResponse

Voorbeeld

getEmailTemplates Voorbeeld

Copy

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

renderEmailTemplate

Parameters

Naam	Type	Vereist
tenantId	string	Ja
renderEmailTemplateBody	RenderEmailTemplateBody	Ja
locale	string	Nee

Response

Retourneert: RenderEmailTemplateResponse

Voorbeeld

renderEmailTemplate Voorbeeld

Copy

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

updateEmailTemplate

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
id	string	Ja
updateEmailTemplateBody	UpdateEmailTemplateBody	Ja

Response

Retourneert: APIEmptyResponse

Voorbeeld

updateEmailTemplate Voorbeeld

Copy

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

getEventLog

req tenantId urlId userIdWS

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
userIdWS	string	Yes
startTime	int64_t	Yes
endTime	int64_t	No

Respons

Retourneert: GetEventLogResponse

Voorbeeld

getEventLog Voorbeeld

Copy

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

getGlobalEventLog

req tenantId urlId userIdWS

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
userIdWS	string	Yes
startTime	int64_t	Yes
endTime	int64_t	No

Respons

Retourneert: GetEventLogResponse

Voorbeeld

getGlobalEventLog Voorbeeld

Copy

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

createFeedPost

Parameters

Naam	Type	Vereist
tenantId	string	Ja
createFeedPostParams	CreateFeedPostParams	Ja
options	const CreateFeedPostOptions&	Ja

Respons

Retourneert: CreateFeedPostsResponse

Voorbeeld

createFeedPost Voorbeeld

Copy

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

createFeedPostPublic

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
createFeedPostParams	CreateFeedPostParams	Ja
options	const CreateFeedPostPublicOptions&	Ja

Respons

Retourneert: CreateFeedPostResponse

Voorbeeld

createFeedPostPublic Voorbeeld

Copy

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

deleteFeedPostPublic

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
postId	string	Ja
options	const DeleteFeedPostPublicOptions&	Ja

Respons

Retourneert: DeleteFeedPostPublicResponse

Voorbeeld

deleteFeedPostPublic Voorbeeld

Copy

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

getFeedPosts

req tenantId afterId

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
options	const GetFeedPostsOptions&	Ja

Respons

Retourneert: GetFeedPostsResponse

Voorbeeld

getFeedPosts Voorbeeld

Copy

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

getFeedPostsPublic

req tenantId afterId

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
options	const GetFeedPostsPublicOptions&	Ja

Respons

Retourneert: PublicFeedPostsResponse

Voorbeeld

getFeedPostsPublic Voorbeeld

Copy

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

getFeedPostsStats

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
postIds	vector<string	Ja
sso	string	Nee

Respons

Retourneert: FeedPostsStatsResponse

Voorbeeld

Voorbeeld getFeedPostsStats

Copy

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

getUserReactsPublic

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
options	const GetUserReactsPublicOptions&	Ja

Reactie

Retourneert: UserReactsResponse

Voorbeeld

getUserReactsPublic Voorbeeld

Copy

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

reactFeedPostPublic

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
postId	string	Ja
reactBodyParams	ReactBodyParams	Ja
options	const ReactFeedPostPublicOptions&	Ja

Respons

Retourneert: ReactFeedPostResponse

Voorbeeld

reactFeedPostPublic Voorbeeld

Copy

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

updateFeedPost

Parameters

Naam	Type	Vereist
tenantId	string	Ja
id	string	Ja
feedPost	FeedPost	Ja

Respons

Retourneert: APIEmptyResponse

Voorbeeld

updateFeedPost Voorbeeld

Copy

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

updateFeedPostPublic

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
postId	string	Ja
updateFeedPostParams	UpdateFeedPostParams	Ja
options	const UpdateFeedPostPublicOptions&	Ja

Response

Retourneert: CreateFeedPostResponse

Voorbeeld

updateFeedPostPublic Voorbeeld

Copy

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

flagCommentPublic

Parameters

Naam	Type	Vereist
tenantId	string	Yes
commentId	string	Yes
isFlagged	bool	Yes
sso	string	No

Respons

Retourneert: APIEmptyResponse

Voorbeeld

flagCommentPublic Voorbeeld

Copy

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

getGifLarge

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
largeInternalURLSanitized	string	Ja

Response

Retourneert: GifGetLargeResponse

Example

getGifLarge Voorbeeld

Copy

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

getGifsSearch

Parameters

Name	Type	Required
tenantId	string	Yes
search	string	Yes
options	const GetGifsSearchOptions&	Yes

Respons

Retourneert: GetGifsSearchResponse

Voorbeeld

getGifsSearch Voorbeeld

Copy

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

getGifsTrending

Parameters

Naam	Type	Vereist	Omschrijving
tenantId	string	Ja
options	const GetGifsTrendingOptions&	Ja

Respons

Retourneert: GetGifsTrendingResponse

Voorbeeld

getGifsTrending Voorbeeld

Copy

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

addHashTag

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
createHashTagBody	CreateHashTagBody	Ja

Response

Retourneert: CreateHashTagResponse

Example

addHashTag Voorbeeld

Copy

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

addHashTagsBulk

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Yes
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Yes

Response

Retourneert: BulkCreateHashTagsResponse

Voorbeeld

addHashTagsBulk Voorbeeld

Copy

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

deleteHashTag

Parameters

Naam	Type	Vereist
tenantId	string	Yes
tag	string	Yes
deleteHashTagRequestBody	DeleteHashTagRequestBody	Yes

Respons

Retourneert: APIEmptyResponse

Voorbeeld

deleteHashTag Voorbeeld

Copy

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

getHashTags

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
page	double	Nee

Respons

Retourneert: GetHashTagsResponse

Voorbeeld

getHashTags voorbeeld

Copy

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

patchHashTag

Parameters

Naam	Type	Verplicht
tenantId	string	Yes
tag	string	Yes
updateHashTagBody	UpdateHashTagBody	Yes

Respons

Retourneert: UpdateHashTagResponse

Voorbeeld

patchHashTag Voorbeeld

Copy

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

deleteModerationVote

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
commentId	string	Ja
voteId	string	Ja
options	const DeleteModerationVoteOptions&	Ja

Respons

Retourneert: VoteDeleteResponse

Voorbeeld

deleteModerationVote Voorbeeld

Copy

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

getApiComments

Parameters

Naam	Type	Vereist	Omschrijving
tenantId	string	Ja
options	const GetApiCommentsOptions&	Ja

Respons

Retourneert: ModerationAPIGetCommentsResponse

Voorbeeld

Voorbeeld getApiComments

Copy

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

getApiExportStatus

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
options	const GetApiExportStatusOptions&	Ja

Response

Returns: ModerationExportStatusResponse

Example

getApiExportStatus Voorbeeld

Copy

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

getApiIds

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
options	const GetApiIdsOptions&	Ja

Respons

Retourneert: ModerationAPIGetCommentIdsResponse

Voorbeeld

Voorbeeld getApiIds

Copy

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

getBanUsersFromComment

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
commentId	string	Ja
sso	string	Nee

Respons

Retourneert: GetBannedUsersFromCommentResponse

Voorbeeld

getBanUsersFromComment Voorbeeld

Copy

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

getCommentBanStatus

Parameters

Naam	Type	Vereist
tenantId	string	Ja
commentId	string	Ja
sso	string	Nee

Respons

Retourneert: GetCommentBanStatusResponse

Voorbeeld

getCommentBanStatus Voorbeeld

Copy

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

getCommentChildren

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
commentId	string	Ja
sso	string	Nee

Respons

Retourneert: ModerationAPIChildCommentsResponse

Voorbeeld

getCommentChildren Voorbeeld

Copy

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

getCount

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
options	const GetCountOptions&	Ja

Respons

Retourneert: ModerationAPICountCommentsResponse

Voorbeeld

getCount Voorbeeld

Copy

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

getCounts

Parameters

Name	Type	Required	Description
tenantId	string	Yes
sso	string	No

Respons

Retourneert: GetBannedUsersCountResponse

Voorbeeld

getCounts voorbeeld

Copy

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

getLogs

Parameters

Naam	Type	Vereist
tenantId	string	Ja
commentId	string	Ja
sso	string	Nee

Respons

Retourneert: ModerationAPIGetLogsResponse

Voorbeeld

getLogs Voorbeeld

Copy

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

getManualBadges

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
sso	string	Nee

Response

Retourneert: GetTenantManualBadgesResponse

Voorbeeld

getManualBadges Voorbeeld

Copy

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

getManualBadgesForUser

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
options	const GetManualBadgesForUserOptions&	Ja

Respons

Retourneert: GetUserManualBadgesResponse

Voorbeeld

getManualBadgesForUser Voorbeeld

Copy

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

getModerationComment

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
commentId	string	Ja
options	const GetModerationCommentOptions&	Ja

Respons

Retourneert: ModerationAPICommentResponse

Voorbeeld

getModerationComment Voorbeeld

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-456");
GetModerationCommentOptions options;
options.includeDeleted = boost::optional<bool>(true);
options.locale = boost::optional<utility::string_t>(utility::conversions::to_string_t("en-US"));
api->getModerationComment(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<ModerationAPICommentResponse>> task) {
        try {
            auto response = task.get();
            // Verwerk de respons naar behoefte
        } catch (const std::exception& ex) {
            // Fout afhandelen
        }
    });

getModerationCommentText

Parameters

Naam	Type	Vereist
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Respons

Retourneert: GetCommentTextResponse

Voorbeeld

getModerationCommentText Voorbeeld

Copy

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

getPreBanSummary

Parameters

Naam	Type	Vereist
tenantId	string	Yes
commentId	string	Yes
options	const GetPreBanSummaryOptions&	Yes

Response

Retourneert: PreBanSummary

Voorbeeld

getPreBanSummary Voorbeeld

Copy

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

getSearchCommentsSummary

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
options	const GetSearchCommentsSummaryOptions&	Ja

Respons

Retourneert: ModerationCommentSearchResponse

Voorbeeld

getSearchCommentsSummary Voorbeeld

Copy

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

getSearchPages

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
options	const GetSearchPagesOptions&	Ja

Reactie

Retourneert: ModerationPageSearchResponse

Voorbeeld

Voorbeeld getSearchPages

Copy

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

getSearchSites

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Yes
options	const GetSearchSitesOptions&	Yes

Response

Retourneert: ModerationSiteSearchResponse

Voorbeeld

Voorbeeld getSearchSites

Copy

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

getSearchSuggest

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
options	const GetSearchSuggestOptions&	Ja

Respons

Returns: ModerationSuggestResponse

Voorbeeld

getSearchSuggest Voorbeeld

Copy

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

getSearchUsers

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
options	const GetSearchUsersOptions&	Ja

Respons

Retourneert: ModerationUserSearchResponse

Voorbeeld

getSearchUsers voorbeeld

Copy

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

getTrustFactor

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
options	const GetTrustFactorOptions&	Ja

Response

Retourneert: GetUserTrustFactorResponse

Example

getTrustFactor Voorbeeld

Copy

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

getUserBanPreference

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
sso	string	Nee

Respons

Retourneert: APIModerateGetUserBanPreferencesResponse

Voorbeeld

Voorbeeld getUserBanPreference

Copy

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

getUserInternalProfile

Parameters

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

Reactie

Retourneert: GetUserInternalProfileResponse

Voorbeeld

getUserInternalProfile Voorbeeld

Copy

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

postAdjustCommentVotes

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
commentId	string	Ja
adjustCommentVotesParams	AdjustCommentVotesParams	Ja
options	const PostAdjustCommentVotesOptions&	Ja

Respons

Retourneert: AdjustVotesResponse

Voorbeeld

postAdjustCommentVotes Voorbeeld

Copy

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

postApiExport

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
options	const PostApiExportOptions&	Ja

Respons

Retourneert: ModerationExportResponse

Voorbeeld

postApiExport Voorbeeld

Copy

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

postBanUserFromComment

Parameters

Naam	Type	Vereist
tenantId	string	Ja
commentId	string	Ja
options	const PostBanUserFromCommentOptions&	Ja

Respons

Retourneert: BanUserFromCommentResult

Voorbeeld

postBanUserFromComment Voorbeeld

Copy

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

postBanUserUndo

Parameters

Naam	Type	Vereist
tenantId	string	Ja
banUserUndoParams	BanUserUndoParams	Ja
sso	string	Nee

Respons

Retourneert: APIEmptyResponse

Voorbeeld

postBanUserUndo voorbeeld

Copy

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

postBulkPreBanSummary

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
bulkPreBanParams	BulkPreBanParams	Ja
options	const PostBulkPreBanSummaryOptions&	Ja

Respons

Retourneert: BulkPreBanSummary

Voorbeeld

postBulkPreBanSummary Voorbeeld

Copy

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

postCommentsByIds

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
commentsByIdsParams	CommentsByIdsParams	Ja
sso	string	Nee

Respons

Retourneert: ModerationAPIChildCommentsResponse

Voorbeeld

postCommentsByIds Voorbeeld

Copy

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

postFlagComment

Parameters

Naam	Type	Vereist
tenantId	string	Yes
commentId	string	Yes
options	const PostFlagCommentOptions&	Yes

Response

Retourneert: APIEmptyResponse

Example

postFlagComment Voorbeeld

Copy

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

postRemoveComment

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
commentId	string	Ja
options	const PostRemoveCommentOptions&	Ja

Respons

Retourneert: PostRemoveCommentApiResponse

Voorbeeld

postRemoveComment Voorbeeld

Copy

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

postRestoreDeletedComment

Parameters

Naam	Type	Vereist
tenantId	string	Yes
commentId	string	Yes
options	const PostRestoreDeletedCommentOptions&	Yes

Respons

Retourneert: APIEmptyResponse

Voorbeeld

postRestoreDeletedComment Voorbeeld

Copy

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

postSetCommentApprovalStatus

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
commentId	string	Ja
options	const PostSetCommentApprovalStatusOptions&	Ja

Response

Retourneert: SetCommentApprovedResponse

Example

postSetCommentApprovalStatus Voorbeeld

Copy

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

postSetCommentReviewStatus

Parameters

Naam	Type	Vereist
tenantId	string	Ja
commentId	string	Ja
options	const PostSetCommentReviewStatusOptions&	Ja

Respons

Retourneert: APIEmptyResponse

Voorbeeld

postSetCommentReviewStatus Voorbeeld

Copy

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

postSetCommentSpamStatus

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
commentId	string	Ja
options	const PostSetCommentSpamStatusOptions&	Ja

Respons

Retourneert: APIEmptyResponse

Voorbeeld

postSetCommentSpamStatus Voorbeeld

Copy

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

postSetCommentText

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
commentId	string	Ja
setCommentTextParams	SetCommentTextParams	Ja
options	const PostSetCommentTextOptions&	Ja

Response

Retourneert: SetCommentTextResponse

Voorbeeld

postSetCommentText Voorbeeld

Copy

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

postUnFlagComment

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
commentId	string	Ja
options	const PostUnFlagCommentOptions&	Ja

Antwoord

Retourneert: APIEmptyResponse

Voorbeeld

postUnFlagComment voorbeeld

Copy

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

postVote

Parameters

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

Respons

Retourneert: VoteResponse

Voorbeeld

postVote Voorbeeld

Copy

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

putAwardBadge

Parameters

Naam	Type	Vereist
tenantId	string	Ja
badgeId	string	Ja
options	const PutAwardBadgeOptions&	Ja

Respons

Retourneert: AwardUserBadgeResponse

Voorbeeld

putAwardBadge Voorbeeld

Copy

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

putCloseThread

Parameters

Naam	Type	Vereist
tenantId	string	Ja
urlId	string	Ja
sso	string	Nee

Respons

Retourneert: APIEmptyResponse

Voorbeeld

putCloseThread voorbeeld

Copy

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

putRemoveBadge

Parameters

Naam	Type	Vereist
tenantId	string	Ja
badgeId	string	Ja
options	const PutRemoveBadgeOptions&	Ja

Respons

Retourneert: RemoveUserBadgeResponse

Voorbeeld

putRemoveBadge Voorbeeld

Copy

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

putReopenThread

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
urlId	string	Ja
sso	string	Nee

Response

Retourneert: APIEmptyResponse

Voorbeeld

putReopenThread Voorbeeld

Copy

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

setTrustFactor

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
options	const SetTrustFactorOptions&	Ja

Response

Retourneert: SetUserTrustFactorResponse

Example

setTrustFactor voorbeeld

Copy

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

createModerator

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
createModeratorBody	CreateModeratorBody	Ja

Respons

Retourneert: CreateModeratorResponse

Voorbeeld

createModerator Voorbeeld

Copy

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

deleteModerator

Parameters

Naam	Type	Vereist
tenantId	string	Ja
id	string	Ja
sendEmail	string	Nee

Respons

Retourneert: APIEmptyResponse

Voorbeeld

deleteModerator voorbeeld

Copy

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

getModerator

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
id	string	Ja

Respons

Retourneert: GetModeratorResponse

Voorbeeld

getModerator Voorbeeld

Copy

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

getModerators

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
skip	double	Nee

Response

Retourneert: GetModeratorsResponse

Example

getModerators Voorbeeld

Copy

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

sendInvite

Parameters

Naam	Type	Vereist
tenantId	string	Yes
id	string	Yes
fromName	string	Yes

Respons

Retourneert: APIEmptyResponse

Voorbeeld

sendInvite Voorbeeld

Copy

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

updateModerator

Parameters

Naam	Type	Verplicht
tenantId	string	Yes
id	string	Yes
updateModeratorBody	UpdateModeratorBody	Yes

Respons

Retourneert: APIEmptyResponse

Voorbeeld

updateModerator voorbeeld

Copy

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

deleteNotificationCount

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Retourneert: APIEmptyResponse

Example

deleteNotificationCount Voorbeeld

Copy

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

getCachedNotificationCount

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
id	string	Ja

Respons

Retourneert: GetCachedNotificationCountResponse

Voorbeeld

getCachedNotificationCount Voorbeeld

Copy

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

getNotificationCount

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
options	const GetNotificationCountOptions&	Ja

Response

Retourneert: GetNotificationCountResponse

Example

getNotificationCount Voorbeeld

Copy

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

getNotifications

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
options	const GetNotificationsOptions&	Ja

Respons

Retourneert: GetNotificationsResponse

Voorbeeld

getNotifications Voorbeeld

Copy

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

updateNotification

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
id	string	Ja
updateNotificationBody	UpdateNotificationBody	Ja
userId	string	Nee

Response

Returns: APIEmptyResponse

Example

updateNotification Voorbeeld

Copy

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

createV1PageReact

Parameters

Naam	Type	Vereist
tenantId	string	Ja
urlId	string	Ja
title	string	Nee

Respons

Retourneert: CreateV1PageReact

Voorbeeld

createV1PageReact Voorbeeld

Copy

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

createV2PageReact

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
urlId	string	Ja
id	string	Ja
title	string	Nee

Respons

Retourneert: CreateV1PageReact

Voorbeeld

createV2PageReact Voorbeeld

Copy

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

deleteV1PageReact

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
urlId	string	Ja

Respons

Returns: CreateV1PageReact

Voorbeeld

deleteV1PageReact Voorbeeld

Copy

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

deleteV2PageReact

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
urlId	string	Ja
id	string	Ja

Respons

Retourneert: CreateV1PageReact

Voorbeeld

deleteV2PageReact Voorbeeld

Copy

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

getV1PageLikes

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
urlId	string	Ja

Respons

Retourneert: GetV1PageLikes

Voorbeeld

getV1PageLikes Voorbeeld

Copy

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

getV2PageReacts

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
urlId	string	Ja

Response

Retourneert: GetV2PageReacts

Example

Voorbeeld getV2PageReacts

Copy

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

getV2PageReactUsers

Parameters

Naam	Type	Vereist
tenantId	string	Ja
urlId	string	Ja
id	string	Ja

Response

Retourneert: GetV2PageReactUsersResponse

Example

Voorbeeld getV2PageReactUsers

Copy

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

addPage

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
createAPIPageData	CreateAPIPageData	Ja

Respons

Retourneert: AddPageAPIResponse

Voorbeeld

addPage Voorbeeld

Copy

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

deletePage

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
id	string	Ja

Respons

Retourneert: DeletePageAPIResponse

Voorbeeld

deletePage Voorbeeld

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto pageId   = utility::conversions::to_string_t("page-456");
api->deletePage(tenantId, pageId)
   .then([](pplx::task<std::shared_ptr<DeletePageAPIResponse>> t) {
       try {
           auto response = t.get();
           // verwerk de respons indien nodig
       } catch (const std::exception& ex) {
           // behandel fout
       }
   });

getOfflineUsers

Past commenters on the page who are NOT currently online. Sorted by displayName.
Use this after exhausting /users/online to render a "Members" section.
Cursor pagination on commenterName: server walks the partial {tenantId, urlId, commenterName}
index from afterName forward via $gt, no $skip cost.

Parameters

Naam	Type	Vereist
tenantId	string	Ja
urlId	string	Ja
options	const GetOfflineUsersOptions&	Ja

Respons

Retourneert: PageUsersOfflineResponse

Voorbeeld

getOfflineUsers Voorbeeld

Copy

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

getOnlineUsers

Momenteel online kijkers van een pagina: mensen waarvan de websocket‑sessie op dit moment op de pagina geabonneerd is.
Retourneert anonCount + totalCount (abonnees in de hele ruimte, inclusief anonieme kijkers die we niet opsommen).

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
urlId	string	Ja
options	const GetOnlineUsersOptions&	Ja

Response

Retourneert: PageUsersOnlineResponse

Voorbeeld

Voorbeeld getOnlineUsers

Copy

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

getPageByURLId

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
urlId	string	Ja

Respons

Retourneert: GetPageByURLIdAPIResponse

Voorbeeld

getPageByURLId Voorbeeld

Copy

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

getPages

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja

Respons

Retourneert: GetPagesAPIResponse

Voorbeeld

getPages Voorbeeld

Copy

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

getPagesPublic

Lijst pagina’s voor een tenant. Wordt gebruikt door de FChat‑desktopclient om zijn kamerlijst te vullen. Vereist enableFChat om true te zijn in de opgeloste aangepaste configuratie voor elke pagina. Pagina’s die SSO vereisen, worden gefilterd op basis van de groepsrechten van de aanvragende gebruiker.

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
options	const GetPagesPublicOptions&	Ja

Respons

Retourneert: GetPublicPagesResponse

Voorbeeld

getPagesPublic Voorbeeld

Copy

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

getUsersInfo

Bulk gebruikersinfo voor een tenant. Gegeven userIds, retourneer weergave‑info van User / SSOUser.
Gebruikt door de commentaarwidget om gebruikers die net verschenen via een presence‑event te verrijken.
Geen paginacontext: privacy wordt uniform afgedwongen (privéprofielen worden gemaskeerd).

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
ids	string	Ja

Response

Retourneert: PageUsersInfoResponse

Voorbeeld

getUsersInfo Voorbeeld

Copy

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

patchPage

Parameters

Naam	Type	Vereist
tenantId	string	Ja
id	string	Ja
updateAPIPageData	UpdateAPIPageData	Ja

Response

Retourneert: PatchPageAPIResponse

Example

patchPage Voorbeeld

Copy

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

deletePendingWebhookEvent

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
id	string	Ja

Response

Retourneert: APIEmptyResponse

Example

deletePendingWebhookEvent Voorbeeld

Copy

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

getPendingWebhookEventCount

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
options	const GetPendingWebhookEventCountOptions&	Ja

Reactie

Retourneert: GetPendingWebhookEventCountResponse

Voorbeeld

getPendingWebhookEventCount Voorbeeld

Copy

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

getPendingWebhookEvents

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Yes
options	const GetPendingWebhookEventsOptions&	Yes

Response

Retourneert: GetPendingWebhookEventsResponse

Voorbeeld

getPendingWebhookEvents voorbeeld

Copy

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

createQuestionConfig

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
createQuestionConfigBody	CreateQuestionConfigBody	Ja

Respons

Retourneert: CreateQuestionConfigResponse

Voorbeeld

createQuestionConfig Voorbeeld

Copy

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

deleteQuestionConfig

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
id	string	Ja

Respons

Returns: APIEmptyResponse

Voorbeeld

deleteQuestionConfig Voorbeeld

Copy

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

getQuestionConfig

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Respons

Retourneert: GetQuestionConfigResponse

Voorbeeld

getQuestionConfig Voorbeeld

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto questionId = utility::conversions::to_string_t("question-456");
api->getQuestionConfig(tenantId, questionId)
    .then([](pplx::task<std::shared_ptr<GetQuestionConfigResponse>> task) {
        try {
            auto response = task.get();
            // Gebruik de respons indien nodig
        } catch (const std::exception&) {
            // Fout afhandelen
        }
    });

getQuestionConfigs

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
skip	double	Nee

Respons

Retourneert: GetQuestionConfigsResponse

Voorbeeld

getQuestionConfigs Voorbeeld

Copy

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

updateQuestionConfig

Parameters

Naam	Type	Vereist
tenantId	string	Yes
id	string	Yes
updateQuestionConfigBody	UpdateQuestionConfigBody	Yes

Reactie

Retourneert: APIEmptyResponse

Voorbeeld

updateQuestionConfig Voorbeeld

Copy

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

createQuestionResult

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
createQuestionResultBody	CreateQuestionResultBody	Ja

Response

Retourneert: CreateQuestionResultResponse

Voorbeeld

createQuestionResult Voorbeeld

Copy

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

deleteQuestionResult

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
id	string	Ja

Respons

Retourneert: APIEmptyResponse

Voorbeeld

deleteQuestionResult Voorbeeld

Copy

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

getQuestionResult

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
id	string	Ja

Response

Retourneert: GetQuestionResultResponse

Example

Voorbeeld getQuestionResult

Copy

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

getQuestionResults

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Yes
options	const GetQuestionResultsOptions&	Yes

Response

Retourneert: GetQuestionResultsResponse

Voorbeeld

getQuestionResults Voorbeeld

Copy

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

updateQuestionResult

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
id	string	Ja
updateQuestionResultBody	UpdateQuestionResultBody	Ja

Reactie

Retourneert: APIEmptyResponse

Voorbeeld

updateQuestionResult Voorbeeld

Copy

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

aggregateQuestionResults

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
options	const AggregateQuestionResultsOptions&	Ja

Respons

Retourneert: AggregateQuestionResultsResponse

Voorbeeld

aggregateQuestionResults Voorbeeld

Copy

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

bulkAggregateQuestionResults

Parameters

Naam	Type	Vereist
tenantId	string	Ja
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Ja
forceRecalculate	bool	Nee

Respons

Retourneert: BulkAggregateQuestionResultsResponse

Voorbeeld

bulkAggregateQuestionResults Voorbeeld

Copy

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

combineCommentsWithQuestionResults

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
options	const CombineCommentsWithQuestionResultsOptions&	Ja

Respons

Retourneert: CombineQuestionResultsWithCommentsResponse

Voorbeeld

combineCommentsWithQuestionResults voorbeeld

Copy

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

addSSOUser

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Yes
createAPISSOUserData	CreateAPISSOUserData	Yes

Response

Retourneert: AddSSOUserAPIResponse

Voorbeeld

addSSOUser Voorbeeld

Copy

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

deleteSSOUser

Parameters

Naam	Type	Vereist
tenantId	string	Ja
id	string	Ja
options	const DeleteSSOUserOptions&	Ja

Respons

Retourneert: DeleteSSOUserAPIResponse

Voorbeeld

deleteSSOUser Voorbeeld

Copy

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

getSSOUserByEmail

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
email	string	Ja

Response

Retourneert: GetSSOUserByEmailAPIResponse

Voorbeeld

Voorbeeld getSSOUserByEmail

Copy

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

getSSOUserById

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
id	string	Ja

Response

Retourneert: GetSSOUserByIdAPIResponse

Example

getSSOUserById Voorbeeld

Copy

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

getSSOUsers

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
skip	int32_t	Nee

Response

Retourneert: GetSSOUsersResponse

Voorbeeld

getSSOUsers Voorbeeld

Copy

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

patchSSOUser

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
id	string	Ja
updateAPISSOUserData	UpdateAPISSOUserData	Ja
updateComments	bool	Nee

Respons

Retourneert: PatchSSOUserAPIResponse

Voorbeeld

patchSSOUser Voorbeeld

Copy

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

putSSOUser

Parameters

Naam	Type	Vereist
tenantId	string	Ja
id	string	Ja
updateAPISSOUserData	UpdateAPISSOUserData	Ja
updateComments	bool	Nee

Reactie

Retourneert: PutSSOUserAPIResponse

Voorbeeld

putSSOUser Voorbeeld

Copy

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

createSubscription

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Ja

Response

Retourneert: CreateSubscriptionAPIResponse

Voorbeeld

createSubscription Voorbeeld

Copy

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

deleteSubscription

Parameters

Naam	Type	Vereist
tenantId	string	Ja
id	string	Ja
userId	string	Nee

Respons

Retourneert: DeleteSubscriptionAPIResponse

Voorbeeld

deleteSubscription Voorbeeld

Copy

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

getSubscriptions

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
userId	string	Nee

Response

Retourneert: GetSubscriptionsAPIResponse

Voorbeeld

getSubscriptions Voorbeeld

Copy

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

updateSubscription

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
id	string	Ja
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	Ja
userId	string	Nee

Respons

Retourneert: UpdateSubscriptionAPIResponse

Voorbeeld

updateSubscription Voorbeeld

Copy

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

getTenantDailyUsages

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
options	const GetTenantDailyUsagesOptions&	Ja

Response

Retourneert: GetTenantDailyUsagesResponse

Voorbeeld

Voorbeeld van getTenantDailyUsages

Copy

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

createTenantPackage

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
createTenantPackageBody	CreateTenantPackageBody	Ja

Respons

Retourneert: CreateTenantPackageResponse

Voorbeeld

createTenantPackage Voorbeeld

Copy

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

deleteTenantPackage

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
id	string	Ja

Respons

Retourneert: APIEmptyResponse

Voorbeeld

deleteTenantPackage Voorbeeld

Copy

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

getTenantPackage

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Respons

Retourneert: GetTenantPackageResponse

Voorbeeld

getTenantPackage Voorbeeld

Copy

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

getTenantPackages

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
skip	double	Nee

Respons

Retourneert: GetTenantPackagesResponse

Voorbeeld

getTenantPackages Voorbeeld

Copy

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

replaceTenantPackage

Parameters

Naam	Type	Vereist
tenantId	string	Ja
id	string	Ja
replaceTenantPackageBody	ReplaceTenantPackageBody	Ja

Respons

Retourneert: APIEmptyResponse

Voorbeeld

replaceTenantPackage Voorbeeld

Copy

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

updateTenantPackage

Parameters

Naam	Type	Vereist
tenantId	string	Ja
id	string	Ja
updateTenantPackageBody	UpdateTenantPackageBody	Ja

Respons

Retourneert: APIEmptyResponse

Voorbeeld

updateTenantPackage Voorbeeld

Copy

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

createTenantUser

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createTenantUserBody	CreateTenantUserBody	Yes

Respons

Retourneert: CreateTenantUserResponse

Voorbeeld

createTenantUser Voorbeeld

Copy

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

deleteTenantUser

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
id	string	Ja
options	const DeleteTenantUserOptions&	Ja

Respons

Retourneert: APIEmptyResponse

Voorbeeld

deleteTenantUser Voorbeeld

Copy

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

getTenantUser

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
id	string	Ja

Respons

Retourneert: GetTenantUserResponse

Voorbeeld

getTenantUser Voorbeeld

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user@example.com");
api->getTenantUser(tenantId, userId)
    .then([](pplx::task<std::shared_ptr<GetTenantUserResponse>> task) {
        try {
            auto response = task.get();
            // Gebruik de response indien nodig
        } catch (const std::exception&) {
            // Foutafhandeling
        }
    });

getTenantUsers

Parameters

Name	Type	Required	Description
tenantId	string	Ja
skip	double	Nee

Respons

Retourneert: GetTenantUsersResponse

Voorbeeld

getTenantUsers Voorbeeld

Copy

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

replaceTenantUser

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
id	string	Ja
replaceTenantUserBody	ReplaceTenantUserBody	Ja
updateComments	string	Nee

Respons

Retourneert: APIEmptyResponse

Voorbeeld

replaceTenantUser Voorbeeld

Copy

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

sendLoginLink

Parameters

Naam	Type	Vereist
tenantId	string	Ja
id	string	Ja
redirectURL	string	Nee

Response

Retourneert: APIEmptyResponse

Example

sendLoginLink Voorbeeld

Copy

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

updateTenantUser

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
id	string	Ja
updateTenantUserBody	UpdateTenantUserBody	Ja
updateComments	string	Nee

Respons

Retourneert: APIEmptyResponse

Voorbeeld

updateTenantUser Voorbeeld

Copy

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

createTenant

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Yes
createTenantBody	CreateTenantBody	Yes

Respons

Retourneert: CreateTenantResponse

Voorbeeld

createTenant Voorbeeld

Copy

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

deleteTenant

Parameters

Naam	Type	Vereist
tenantId	string	Ja
id	string	Ja
sure	string	Nee

Respons

Retourneert: APIEmptyResponse

Voorbeeld

deleteTenant Voorbeeld

Copy

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

getTenant

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
id	string	Ja

Respons

Retourneert: GetTenantResponse

Voorbeeld

getTenant Voorbeeld

Copy

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

getTenants

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
options	const GetTenantsOptions&	Ja

Respons

Retourneert: GetTenantsResponse

Voorbeeld

getTenants Voorbeeld

Copy

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

updateTenant

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
id	string	Ja
updateTenantBody	UpdateTenantBody	Ja

Response

Retourneert: APIEmptyResponse

Voorbeeld

updateTenant Voorbeeld

Copy

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

changeTicketState

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
userId	string	Ja
id	string	Ja
changeTicketStateBody	ChangeTicketStateBody	Ja

Respons

Retourneert: ChangeTicketStateResponse

Voorbeeld

changeTicketState Voorbeeld

Copy

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

createTicket

Parameters

Naam	Type	Vereist
tenantId	string	Ja
userId	string	Ja
createTicketBody	CreateTicketBody	Ja

Respons

Retourneert: CreateTicketResponse

Voorbeeld

createTicket Voorbeeld

Copy

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

getTicket

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
id	string	Ja
userId	string	Nee

Respons

Retourneert: GetTicketResponse

Voorbeeld

getTicket Voorbeeld

Copy

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

getTickets

Parameters

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

Response

Returns: GetTicketsResponse

Example

getTickets Voorbeeld

Copy

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

getTranslations

Parameters

Naam	Type	Verplicht
r_namespace	string	Ja
component	string	Ja
options	const GetTranslationsOptions&	Ja

Respons

Retourneert: GetTranslationsResponse

Voorbeeld

getTranslations Voorbeeld

Copy

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

uploadImage

Upload en schaaf een afbeelding

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
file	HttpContent	Ja
options	const UploadImageOptions&	Ja

Response

Retourneert: UploadImageResponse

Example

uploadImage Voorbeeld

Copy

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

getUserBadgeProgressById

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Yes
id	string	Yes

Respons

Retourneert: APIGetUserBadgeProgressResponse

Voorbeeld

getUserBadgeProgressById Voorbeeld

Copy

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

getUserBadgeProgressByUserId

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Yes
userId	string	Yes

Reactie

Retourneert: APIGetUserBadgeProgressResponse

Voorbeeld

getUserBadgeProgressByUserId Voorbeeld

Copy

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

getUserBadgeProgressList

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
options	const GetUserBadgeProgressListOptions&	Ja

Antwoord

Retourneert: APIGetUserBadgeProgressListResponse

Voorbeeld

getUserBadgeProgressList Voorbeeld

Copy

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

createUserBadge

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
createUserBadgeParams	CreateUserBadgeParams	Ja

Respons

Retourneert: APICreateUserBadgeResponse

Voorbeeld

createUserBadge Voorbeeld

Copy

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

deleteUserBadge

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Yes
id	string	Yes

Respons

Retourneert: APIEmptySuccessResponse

Voorbeeld

deleteUserBadge Voorbeeld

Copy

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

getUserBadge

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
id	string	Ja

Response

Retourneert: APIGetUserBadgeResponse

Voorbeeld

getUserBadge Voorbeeld

Copy

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

getUserBadges

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
options	const GetUserBadgesOptions&	Ja

Respons

Retourneert: APIGetUserBadgesResponse

Voorbeeld

getUserBadges Voorbeeld

Copy

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

updateUserBadge

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
id	string	Ja
updateUserBadgeParams	UpdateUserBadgeParams	Ja

Respons

Retourneert: APIEmptySuccessResponse

Voorbeeld

updateUserBadge Voorbeeld

Copy

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

getUserNotificationCount

Parameters

Naam	Type	Vereist	Beschrijving
tenantId	string	Ja
sso	string	Nee

Respons

Retourneert: GetUserNotificationCountResponse

Voorbeeld

Voorbeeld getUserNotificationCount

Copy

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

getUserNotifications

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
options	const GetUserNotificationsOptions&	Ja

Respons

Retourneert: GetMyNotificationsResponse

Voorbeeld

getUserNotifications Voorbeeld

Copy

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

resetUserNotificationCount

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
sso	string	Nee

Response

Retourneert: ResetUserNotificationsResponse

Example

resetUserNotificationCount Voorbeeld

Copy

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

resetUserNotifications

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
options	const ResetUserNotificationsOptions&	Ja

Respons

Retourneert: ResetUserNotificationsResponse

Voorbeeld

resetUserNotifications Voorbeeld

Copy

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

updateUserNotificationCommentSubscriptionStatus

Schakel meldingen in of uit voor een specifiek commentaar.

Parameters

Naam	Type	Verplicht
tenantId	string	Yes
notificationId	string	Yes
optedInOrOut	string	Yes
commentId	string	Yes
sso	string	No

Response

Retourneert: UpdateUserNotificationCommentSubscriptionStatusResponse

Example

Voorbeeld van updateUserNotificationCommentSubscriptionStatus

Copy

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

updateUserNotificationPageSubscriptionStatus

Enable of schakel meldingen voor een pagina in of uit. Wanneer gebruikers zich op een pagina abonneren, worden meldingen aangemaakt voor nieuwe hoofdreacties, en ook

Parameters

Naam	Type	Vereist
tenantId	string	Ja
urlId	string	Ja
url	string	Ja
pageTitle	string	Ja
subscribedOrUnsubscribed	string	Ja
sso	string	Nee

Respons

Returns: UpdateUserNotificationPageSubscriptionStatusResponse

Voorbeeld

updateUserNotificationPageSubscriptionStatus Voorbeeld

Copy

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

updateUserNotificationStatus

Parameters

Naam	Type	Vereist
tenantId	string	Ja
notificationId	string	Ja
newStatus	string	Ja
sso	string	Nee

Respons

Retourneert: UpdateUserNotificationStatusResponse

Voorbeeld

updateUserNotificationStatus Voorbeeld

Copy

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

getUserPresenceStatuses

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
urlIdWS	string	Ja
userIds	string	Ja

Respons

Retourneert: GetUserPresenceStatusesResponse

Voorbeeld

getUserPresenceStatuses Voorbeeld

Copy

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

searchUsers

Parameters

Naam	Type	Verplicht
tenantId	string	Ja
urlId	string	Ja
options	const SearchUsersOptions&	Ja

Respons

Retourneert: SearchUsersResult

Voorbeeld

searchUsers Voorbeeld

Copy

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

getUser

Parameters

Naam	Type	Verplicht	Beschrijving
tenantId	string	Ja
id	string	Ja

Respons

Retourneert: GetUserResponse

Voorbeeld

getUser Voorbeeld

Copy

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

createVote

Parameters

Naam	Type	Verplicht
tenantId	string	Yes
commentId	string	Yes
direction	string	Yes
options	const CreateVoteOptions&	Yes

Response

Retourneert: VoteResponse

Voorbeeld

createVote Voorbeeld

Copy

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

deleteVote

Parameters

Naam	Type	Verplicht
tenantId	string	Yes
id	string	Yes
editKey	string	No

Respons

Retourneert: VoteDeleteResponse

Voorbeeld

deleteVote Voorbeeld

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto voteId = utility::conversions::to_string_t("vote-9876");
boost::optional<utility::string_t> editKey = utility::conversions::to_string_t("edit-abc123");
api->deleteVote(tenantId, voteId, editKey).then([](pplx::task<std::shared_ptr<VoteDeleteResponse>> task) {
    try {
        auto response = task.get();
        // Verwerk de respons indien nodig
    } catch (const std::exception&) {
        // Fout afhandelen
    }
});

---

getVotes

Parameters

Name	Type	Required	Description
tenantId	string	Yes
urlId	string	Yes

Respons

Retourneert: GetVotesResponse

Voorbeeld

getVotes Voorbeeld

Copy

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

getVotesForUser

Parameters

Naam	Type	Vereist
tenantId	string	Ja
urlId	string	Ja
options	const GetVotesForUserOptions&	Ja

Respons

Retourneert: GetVotesForUserResponse

Voorbeeld

getVotesForUser Voorbeeld

Copy

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

Hulp nodig?

Als u problemen ondervindt of vragen heeft over de C++ SDK, doe dan het volgende:

Bijdragen

Bijdragen zijn welkom! Bezoek de GitHub repository voor richtlijnen voor bijdragen.

Taal 🇳🇱 Nederlands

Documentatie

Aan de slag

API-referentie

Gebruik

Aggregatie

Audit-logboeken

Authenticatie

Blokkeren vanuit reactie

Controleer geblokkeerde reacties

Reacties

Reacties voor gebruiker

Domeinconfiguraties

E-mailsjablonen

Gebeurtenislogboek

Feed-berichten

Reactie signaleren

Gifs

Hashtags

Moderatie

Moderators

Aantal meldingen

Meldingen

Pagina-reacties

Pagina's

Wachtende webhook-evenementen

Vraagconfiguraties

Vraagresultaten

Aggregatie van vraagresultaten

SSO-gebruikers

Abonnementen

Dagelijks gebruik van tenant

Tenant-pakketten

Tenant-gebruikers

Tenants

Tickets

Vertalingen

Afbeelding uploaden

Voortgang gebruikersbadge

Gebruikersbadges

Gebruikersmeldingen

Gebruikersaanwezigheidsstatus

Zoeken naar gebruikers

Gebruikers

Stemmen

FastComments C++ SDK

Repository

Vereisten

Installatie

Installeer afhankelijkheden

Bouwen vanuit bron

Installeren

Bibliotheekinhoud

Publieke versus beveiligde API's

Snel aan de slag

Gebruik van geauthentiseerde API's (DefaultAPI)

Gebruik van openbare API's (PublicAPI)

Gebruik van moderatie-API's (ModerationApi)

Veelvoorkomende problemen

API-aanroepen uitvoeren: synchroon vs asynchroon

Synchrone Aanroepen met .get()

Asynchrone Aanroepen met .then()

Keuze tussen synchrone en asynchrone

Notities

Broadcast-id's

SSO (Single Sign-On)

SSO-gebruik

Eenvoudige SSO

Beveiligde SSO

Documentatie voor fastcomments

Documentatie voor API-eindpunten

Documentatie voor Modellen

aggregate

Parameters

Response

Voorbeeld

getAuditLogs

Parameters

Respons

Voorbeeld

Synchrone Aanroepen met `.get()`

Asynchrone Aanroepen met `.then()`