FastComments C++ SDK

This is the official C++ SDK for FastComments.

Official C++ SDK for the FastComments API

Repository

Requirements

C++17 or later
CMake 3.14 or later
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (automatically downloaded for testing)

Installation

Install Dependencies

sudo apt install libcpprest-dev libboost-all-dev

Building from Source

mkdir build
cd build
cmake ..
make

Installing

sudo make install

Library Contents

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

API Client Library Docs

Public vs Secured APIs

For the API client, there are two classes, DefaultAPI and PublicAPI. The DefaultAPI contains methods that require your API key, and PublicAPI contains api calls that can be made directly from a browser/mobile device/etc without authentication.

Quick Start

Using Authenticated APIs (DefaultAPI)

Important:

You must set the base URL (cpp-restsdk generator doesn't read it from the OpenAPI spec)
You must set your API key on the ApiClient before making authenticated requests. If you don't, requests will fail with a 401 error.

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

Using Public APIs (PublicAPI)

Public endpoints don't require authentication:

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

Common Issues

"URI must contain a hostname" error: Make sure you call config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) before creating the ApiClient. The cpp-restsdk generator doesn't automatically read the server URL from the OpenAPI spec.
401 "missing-api-key" error: Make sure you call config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) before creating the DefaultAPI instance.
Wrong API class: Use DefaultAPI for server-side authenticated requests, PublicAPI for client-side/public requests.

Making API Calls: Synchronous vs Asynchronous

All API methods in this SDK return pplx::task<std::shared_ptr<ResponseType>> from the C++ REST SDK. This gives you flexibility in how you handle API responses.

Synchronous Calls with `.get()`

Use .get() to block the calling thread until the request completes and retrieve the result synchronously:

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

// Call .get() to block and get the result synchronously
auto response = api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    boost::none,  // page
    boost::none,  // limit
    boost::none,  // skip
    boost::none,  // asTree
    boost::none,  // skipChildren
    boost::none,  // limitChildren
    boost::none,  // maxTreeDepth
    utility::conversions::to_string_t("your-url-id"),  // urlId
    boost::none,  // userId
    boost::none,  // anonUserId
    boost::none,  // contextUserId
    boost::none,  // hashTag
    boost::none,  // parentId
    boost::none   // direction
).get();  // Blocks until the HTTP request completes

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

Asynchronous Calls with `.then()`

Use .then() for non-blocking asynchronous execution with 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);

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

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

Choosing Between Synchronous and Asynchronous

The choice depends on your runtime environment and application architecture:

.get() (Synchronous blocking)

Blocks the calling thread until the HTTP request completes
Simpler code flow, easier to reason about
Suitable for dedicated worker threads, batch processing, or command-line tools
Not suitable for event loops, GUI threads, or single-threaded servers

.then() (Asynchronous non-blocking)

Returns immediately, callback executes when request completes
Does not block the calling thread
Required for event-driven architectures, GUI applications, or single-threaded event loops
Allows chaining multiple operations
More complex control flow

The SDK's test suite uses .get() exclusively, but this is appropriate for the test environment where blocking is acceptable.

Notes

Broadcast Ids

You'll see you're supposed to pass a broadcastId in some API calls. When you receive events, you'll get this ID back, so you know to ignore the event if you plan to optimistically apply changes on the client (which you'll probably want to do since it offers the best experience). Pass a UUID here. The ID should be unique enough to not occur twice in a browser session.

SSO (Single Sign-On)

For SSO examples, see below.

SSO Usage

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

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

Testing

Set the required environment variables:

export FASTCOMMENTS_API_KEY="your-api-key"
export FASTCOMMENTS_TENANT_ID="your-tenant-id"

Run the tests:

cd build
ctest

Development

To update the generated client from the OpenAPI spec:

./update.sh

Support

For support, please visit https://fastcomments.com/auth/my-account/help or email support@fastcomments.com

Documentation for fastcomments

Documentation for API Endpoints

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

Class	Method	HTTP request	Description
DefaultApi	addDomainConfig	POST /api/v1/domain-configs
DefaultApi	addPage	POST /api/v1/pages
DefaultApi	addSSOUser	POST /api/v1/sso-users
DefaultApi	aggregate	POST /api/v1/aggregate	Aggregates documents by grouping them (if groupBy is provided) and applying multiple operations. Different operations (e.g. sum, countDistinct, avg, etc.) are supported.
DefaultApi	aggregateQuestionResults	GET /api/v1/question-results-aggregation
DefaultApi	blockUserFromComment	POST /api/v1/comments/{id}/block
DefaultApi	bulkAggregateQuestionResults	POST /api/v1/question-results-aggregation/bulk
DefaultApi	combineCommentsWithQuestionResults	GET /api/v1/question-results-aggregation/combine/comments
DefaultApi	createFeedPost	POST /api/v1/feed-posts
DefaultApi	createSubscription	POST /api/v1/subscriptions
DefaultApi	createUserBadge	POST /api/v1/user-badges
DefaultApi	deleteComment	DELETE /api/v1/comments/{id}
DefaultApi	deleteDomainConfig	DELETE /api/v1/domain-configs/{domain}
DefaultApi	deletePage	DELETE /api/v1/pages/{id}
DefaultApi	deleteSSOUser	DELETE /api/v1/sso-users/{id}
DefaultApi	deleteSubscription	DELETE /api/v1/subscriptions/{id}
DefaultApi	deleteUserBadge	DELETE /api/v1/user-badges/{id}
DefaultApi	flagComment	POST /api/v1/comments/{id}/flag
DefaultApi	getAuditLogs	GET /api/v1/audit-logs
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	getFeedPosts	GET /api/v1/feed-posts	req tenantId afterId
DefaultApi	getPageByURLId	GET /api/v1/pages/by-url-id
DefaultApi	getPages	GET /api/v1/pages
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	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	patchDomainConfig	PATCH /api/v1/domain-configs/{domainToUpdate}
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	saveComment	POST /api/v1/comments
DefaultApi	saveCommentsBulk	POST /api/v1/comments/bulk
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	updateFeedPost	PATCH /api/v1/feed-posts/{id}
DefaultApi	updateUserBadge	PUT /api/v1/user-badges/{id}
PublicApi	blockFromCommentPublic	POST /block-from-comment/{commentId}
PublicApi	checkedCommentsForBlocked	GET /check-blocked-comments
PublicApi	createCommentPublic	POST /comments/{tenantId}
PublicApi	createFeedPostPublic	POST /feed-posts/{tenantId}
PublicApi	deleteCommentPublic	DELETE /comments/{tenantId}/{commentId}
PublicApi	deleteCommentVote	DELETE /comments/{tenantId}/{commentId}/vote/{voteId}
PublicApi	deleteFeedPostPublic	DELETE /feed-posts/{tenantId}/{postId}
PublicApi	flagCommentPublic	POST /flag-comment/{commentId}
PublicApi	getCommentText	GET /comments/{tenantId}/{commentId}/text
PublicApi	getCommentVoteUserNames	GET /comments/{tenantId}/{commentId}/votes
PublicApi	getCommentsPublic	GET /comments/{tenantId}	req tenantId urlId
PublicApi	getEventLog	GET /event-log/{tenantId}	req tenantId urlId userIdWS
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	req tenantId afterId
PublicApi	getFeedPostsStats	GET /feed-posts/{tenantId}/stats
PublicApi	getGlobalEventLog	GET /event-log/global/{tenantId}	req tenantId urlId userIdWS
PublicApi	getUserNotificationCount	GET /user-notifications/get-count
PublicApi	getUserNotifications	GET /user-notifications
PublicApi	getUserPresenceStatuses	GET /user-presence-status
PublicApi	getUserReactsPublic	GET /feed-posts/{tenantId}/user-reacts
PublicApi	lockComment	POST /comments/{tenantId}/{commentId}/lock
PublicApi	pinComment	POST /comments/{tenantId}/{commentId}/pin
PublicApi	reactFeedPostPublic	POST /feed-posts/{tenantId}/react/{postId}
PublicApi	resetUserNotificationCount	POST /user-notifications/reset-count
PublicApi	resetUserNotifications	POST /user-notifications/reset
PublicApi	searchUsers	GET /user-search/{tenantId}
PublicApi	setCommentText	POST /comments/{tenantId}/{commentId}/update-text
PublicApi	unBlockCommentPublic	DELETE /block-from-comment/{commentId}
PublicApi	unLockComment	POST /comments/{tenantId}/{commentId}/unlock
PublicApi	unPinComment	POST /comments/{tenantId}/{commentId}/unpin
PublicApi	updateFeedPostPublic	PUT /feed-posts/{tenantId}/{postId}
PublicApi	updateUserNotificationCommentSubscriptionStatus	POST /user-notifications/{notificationId}/mark-opted/{optedInOrOut}	Enable or disable notifications for a specific comment.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Enable or disable notifications for a page. When users are subscribed to a page, notifications are created for new root comments, and also
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Upload and resize an image
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Documentation for Models

Documentation for Authorization

api_key

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

addDomainConfig

Parameters

Name	Type	Required	Description
tenantId	string	Yes
addDomainConfigParams	AddDomainConfigParams	Yes

Response

Returns: AddDomainConfig_200_response

Example

addDomainConfig Example

Copy

AddDomainConfigParams params;
params.domain = utility::string_t(U("comments.example.com"));
params.contactEmail = utility::string_t(U("admin@example.com"));
params.enforceHttps = boost::optional<bool>(true);
params.notes = boost::optional<utility::string_t>(utility::string_t(U("Primary comments domain")));
api->addDomainConfig(utility::string_t(U("my-tenant-123")), params)
.then([](std::shared_ptr<AddDomainConfig_200_response> resp){
    if (!resp) return;
    auto result = std::make_shared<AddDomainConfig_200_response>(*resp);
    std::wcout << U("Domain config added for tenant: my-tenant-123") << std::endl;
});

addPage

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createAPIPageData	CreateAPIPageData	Yes

Response

Returns: AddPageAPIResponse

Example

addPage Example

Copy

utility::string_t tenantId = U("my-tenant-123");
auto createReq = std::make_shared<CreateAPIPageData>();
createReq->url = U("https://docs.example.com/getting-started");
createReq->title = U("Getting Started Guide");
createReq->authorEmail = U("doc-owner@example.com");
createReq->isPublished = boost::optional<bool>(true);
createReq->summary = boost::optional<utility::string_t>(U("Introductory setup and usage"));
api->addPage(tenantId, *createReq).then([](pplx::task<std::shared_ptr<AddPageAPIResponse>> task){
    try {
        auto resp = task.get();
        if (resp) {
            utility::string_t pageId = resp->pageId;
            utility::string_t status = resp->status;
            (void)pageId; (void)status;
        }
    } catch (const std::exception& e) {
        (void)e;
    }
});

addSSOUser

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createAPISSOUserData	CreateAPISSOUserData	Yes

Response

Returns: AddSSOUserAPIResponse

Example

addSSOUser Example

Copy

auto payload = std::make_shared<CreateAPISSOUserData>();
payload->email = utility::string_t(U("jane.doe@example.com"));
payload->displayName = utility::string_t(U("Jane Doe"));
payload->ssoId = utility::string_t(U("jdoe-azure-12345"));
payload->roles = std::vector<utility::string_t>{ utility::string_t(U("moderator")) };
payload->externalId = boost::optional<utility::string_t>(utility::string_t(U("ext-9876")));
payload->sendInvite = boost::optional<bool>(true);
api->addSSOUser(utility::string_t(U("my-tenant-123")), *payload)
.then([](std::shared_ptr<AddSSOUserAPIResponse> resp){
    if (resp) std::cout << "Added SSO user successfully\n";
    else std::cout << "Failed to add SSO user\n";
});

aggregate

Parameters

Name	Type	Required
tenantId	string	Yes
aggregationRequest	AggregationRequest	Yes
parentTenantId	string	No
includeStats	bool	No

Response

Returns: AggregationResponse

Example

aggregate Example

Copy

utility::string_t tenantId = U("my-tenant-123");
auto aggregationRequest = std::make_shared<AggregationRequest>();
boost::optional<utility::string_t> parentTenantId = boost::optional<utility::string_t>(U("parent-tenant-456"));
boost::optional<bool> includeStats = boost::optional<bool>(true);
api->aggregate(tenantId, *aggregationRequest, parentTenantId, includeStats)
.then([](std::shared_ptr<AggregationResponse> resp) {
    if (resp) {
        return resp;
    }
    return std::shared_ptr<AggregationResponse>();
});

aggregateQuestionResults

Parameters

Name	Type	Required
tenantId	string	Yes
questionId	string	No
questionIds	vector<string	No
urlId	string	No
timeBucket	AggregateTimeBucket	No
startDate	datetime	No
forceRecalculate	bool	No

Response

Returns: AggregateQuestionResults_200_response

Example

aggregateQuestionResults Example

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> questionId(U("question-456"));
boost::optional<std::vector<utility::string_t>> questionIds(std::vector<utility::string_t>{U("question-456"), U("question-789")});
boost::optional<utility::string_t> urlId(U("url-55"));
boost::optional<AggregateTimeBucket> timeBucket;
boost::optional<utility::datetime> startDate(utility::datetime::from_string(U("2024-01-01T00:00:00Z")));
boost::optional<bool> forceRecalculate(true);
api->aggregateQuestionResults(tenantId, questionId, questionIds, urlId, timeBucket, startDate, forceRecalculate)
.then([](pplx::task<std::shared_ptr<AggregateQuestionResults_200_response>> t){
    try {
        auto resp = t.get();
        if(!resp) resp = std::make_shared<AggregateQuestionResults_200_response>();
    } catch(const std::exception&) {}
});

blockFromCommentPublic

Parameters

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

Response

Returns: BlockFromCommentPublic_200_response

Example

blockFromCommentPublic Example

Copy

utility::string_t tenantId = utility::string_t(U("my-tenant-123"));
utility::string_t commentId = utility::string_t(U("comment-456"));
PublicBlockFromCommentParams params;
boost::optional<utility::string_t> sso = utility::string_t(U("sso-token-abc123"));
api->blockFromCommentPublic(tenantId, commentId, params, sso)
.then([](pplx::task<std::shared_ptr<BlockFromCommentPublic_200_response>> task){
    try {
        auto resp = task.get();
        if (!resp) resp = std::make_shared<BlockFromCommentPublic_200_response>();
        std::cout << "BlockFromCommentPublic completed\n";
    } catch (const std::exception& e) {
        std::cerr << "BlockFromCommentPublic error: " << e.what() << '\n';
    }
});

blockUserFromComment

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
blockFromCommentParams	BlockFromCommentParams	Yes
userId	string	No
anonUserId	string	No

Response

Returns: BlockFromCommentPublic_200_response

Example

blockUserFromComment Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("comment-456");
BlockFromCommentParams params;
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<utility::string_t> anonUserId = boost::none;
api->blockUserFromComment(tenantId, commentId, params, userId, anonUserId)
    .then([](pplx::task<std::shared_ptr<BlockFromCommentPublic_200_response>> t){
        try {
            auto resp = t.get();
            if (resp) {
                auto copy = std::make_shared<BlockFromCommentPublic_200_response>(*resp);
            }
        } catch (const std::exception&) {
        }
    });

bulkAggregateQuestionResults

Parameters

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

Response

Returns: BulkAggregateQuestionResults_200_response

Example

bulkAggregateQuestionResults Example

Copy

utility::string_t tenantId = U("my-tenant-123");
auto req = std::make_shared<BulkAggregateQuestionResultsRequest>();
boost::optional<bool> forceRecalculate(true);
api->bulkAggregateQuestionResults(tenantId, req, forceRecalculate)
    .then([](pplx::task<std::shared_ptr<BulkAggregateQuestionResults_200_response>> t){
        try {
            auto resp = t.get();
            (void)resp;
        } catch (const std::exception& e) {
            (void)e;
        }
    });

checkedCommentsForBlocked

Parameters

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

Response

Returns: CheckedCommentsForBlocked_200_response

Example

checkedCommentsForBlocked Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentIds = U("cmt-456,cmt-789");
boost::optional<utility::string_t> sso{ U("user@example.com") };
api->checkedCommentsForBlocked(tenantId, commentIds, sso)
.then([](std::shared_ptr<CheckedCommentsForBlocked_200_response> resp){
    auto copied = std::make_shared<CheckedCommentsForBlocked_200_response>(*resp);
    return copied;
})
.then([](std::shared_ptr<CheckedCommentsForBlocked_200_response> finalResult){
    (void)finalResult;
})
.wait();

combineCommentsWithQuestionResults

Parameters

Name	Type	Required
tenantId	string	Yes
questionId	string	No
questionIds	vector<string	No
urlId	string	No
startDate	datetime	No
forceRecalculate	bool	No
minValue	double	No
maxValue	double	No
limit	double	No

Response

Returns: CombineCommentsWithQuestionResults_200_response

Example

combineCommentsWithQuestionResults Example

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> questionId = boost::optional<utility::string_t>(U("q-456"));
boost::optional<std::vector<utility::string_t>> questionIds = std::vector<utility::string_t>{ U("q-456"), U("q-789") };
boost::optional<utility::string_t> urlId = boost::optional<utility::string_t>(U("url-321"));
utility::datetime sd = utility::datetime::from_string(U("2025-01-01T00:00:00Z"));
boost::optional<utility::datetime> startDate = sd;
boost::optional<bool> forceRecalculate = true;
boost::optional<double> minValue = 0.0;
boost::optional<double> maxValue = 5.0;
boost::optional<double> limit = 100.0;
api->combineCommentsWithQuestionResults(tenantId, questionId, questionIds, urlId, startDate, forceRecalculate, minValue, maxValue, limit)
.then([](pplx::task<std::shared_ptr<CombineCommentsWithQuestionResults_200_response>> task){
    try {
        auto resp = task.get();
        auto copy = std::make_shared<CombineCommentsWithQuestionResults_200_response>(*resp);
        (void)copy;
    } catch(const std::exception &){
    }
});

createCommentPublic

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
commentData	CommentData	Yes
sessionId	string	No
sso	string	No

Response

Returns: CreateCommentPublic_200_response

Example

createCommentPublic Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("articles/how-to-cpprest");
utility::string_t broadcastId = U("broadcast-987");
auto commentDataPtr = std::make_shared<CommentData>();
commentDataPtr->text = U("Great article! Learned a lot.");
commentDataPtr->authorEmail = U("reader@example.com");
boost::optional<utility::string_t> sessionId = boost::optional<utility::string_t>(U("session-abc-123"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-token-456"));
api->createCommentPublic(tenantId, urlId, broadcastId, *commentDataPtr, sessionId, sso)
.then([](std::shared_ptr<CreateCommentPublic_200_response> resp){
    if (resp) {}
});

createFeedPost

Parameters

Name	Type	Required
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
broadcastId	string	No
isLive	bool	No
doSpamCheck	bool	No
skipDupCheck	bool	No

Response

Returns: CreateFeedPost_200_response

Example

createFeedPost Example

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateFeedPostParams createFeedPostParams;
createFeedPostParams.title = U("Product update: v2.1");
createFeedPostParams.content = U("We are releasing version 2.1 with performance and stability improvements.");
createFeedPostParams.authorEmail = U("author@example.com");
boost::optional<utility::string_t> broadcastId = boost::optional<utility::string_t>(U("broadcast-789"));
boost::optional<bool> isLive = boost::optional<bool>(true);
boost::optional<bool> doSpamCheck = boost::optional<bool>(false);
boost::optional<bool> skipDupCheck = boost::optional<bool>(false);
api->createFeedPost(tenantId, createFeedPostParams, broadcastId, isLive, doSpamCheck, skipDupCheck)
.then([](pplx::task<std::shared_ptr<CreateFeedPost_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<CreateFeedPost_200_response>(*resp);
            std::cout << "Feed post created" << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << "CreateFeedPost failed: " << e.what() << std::endl;
    }
});

createFeedPostPublic

Parameters

Name	Type	Required
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
broadcastId	string	No
sso	string	No

Response

Returns: CreateFeedPostPublic_200_response

Example

createFeedPostPublic Example

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateFeedPostParams feedParams = CreateFeedPostParams();
boost::optional<utility::string_t> broadcastId = boost::optional<utility::string_t>(U("broadcast-456"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("alice@example.com"));
api->createFeedPostPublic(tenantId, feedParams, broadcastId, sso)
.then([](pplx::task<std::shared_ptr<CreateFeedPostPublic_200_response>> t){
    try {
        auto resp = t.get();
        auto respCopy = std::make_shared<CreateFeedPostPublic_200_response>(*resp);
        (void)respCopy;
    } catch (...) {}
});

createSubscription

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Yes

Response

Returns: CreateSubscriptionAPIResponse

Example

createSubscription Example

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateAPIUserSubscriptionData subscriptionData;
subscriptionData.userEmail = U("user@example.com");
subscriptionData.planId = U("pro-monthly");
subscriptionData.autoRenew = boost::optional<bool>(true);
subscriptionData.couponCode = boost::optional<utility::string_t>(U("WELCOME10"));
auto task = api->createSubscription(tenantId, subscriptionData)
.then([=](pplx::task<std::shared_ptr<CreateSubscriptionAPIResponse>> t) {
    try {
        return t.get();
    } catch (const std::exception&) {
        return std::make_shared<CreateSubscriptionAPIResponse>();
    }
});

createUserBadge

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createUserBadgeParams	CreateUserBadgeParams	Yes

Response

Returns: CreateUserBadge_200_response

Example

createUserBadge Example

Copy

utility::string_t tenantId = U("my-tenant-123");
auto params = std::make_shared<CreateUserBadgeParams>();
params->userId = utility::string_t(U("user@example.com"));
params->badgeId = utility::string_t(U("top-contributor"));
params->awardedBy = boost::optional<utility::string_t>(utility::string_t(U("moderator@example.com")));
params->expiresAt = boost::optional<utility::string_t>(utility::string_t(U("2026-12-31T23:59:59Z")));
api->createUserBadge(tenantId, *params)
    .then([](pplx::task<std::shared_ptr<CreateUserBadge_200_response>> t) {
        try {
            auto resp = t.get();
            (void)resp;
        } catch (const std::exception&) {
        }
    });

deleteComment

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
contextUserId	string	No
isLive	bool	No

Response

Returns: DeleteComment_200_response

Example

deleteComment Example

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
utility::string_t id = utility::conversions::to_string_t("comment-987654");
boost::optional<utility::string_t> contextUserId = utility::conversions::to_string_t("user@example.com");
boost::optional<bool> isLive = true;
api->deleteComment(tenantId, id, contextUserId, isLive)
.then([](pplx::task<std::shared_ptr<DeleteComment_200_response>> t){
    try {
        auto resp = t.get();
        auto dummy = std::make_shared<DeleteComment_200_response>();
        (void)resp;
        (void)dummy;
    } catch (...) {}
});

deleteCommentPublic

Parameters

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

Response

Returns: DeleteCommentPublic_200_response

Example

deleteCommentPublic Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-7890");
utility::string_t broadcastId = U("bcast-456");
boost::optional<utility::string_t> editKey = utility::string_t(U("editKey-abc123"));
boost::optional<utility::string_t> sso = boost::none;
api->deleteCommentPublic(tenantId, commentId, broadcastId, editKey, sso)
.then([](std::shared_ptr<DeleteCommentPublic_200_response> resp) {
    auto copy = std::make_shared<DeleteCommentPublic_200_response>(*resp);
    (void)copy;
});

deleteCommentVote

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
voteId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
editKey	string	No
sso	string	No

Response

Returns: DeleteCommentVote_200_response

Example

deleteCommentVote Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("comment-456");
utility::string_t voteId = U("vote-789");
utility::string_t urlId = U("article-2025-11-20");
utility::string_t broadcastId = U("broadcast-001");
boost::optional<utility::string_t> editKey = boost::optional<utility::string_t>(U("edit-KEY-xyz"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-token-abc"));
api->deleteCommentVote(tenantId, commentId, voteId, urlId, broadcastId, editKey, sso)
.then([](pplx::task<std::shared_ptr<DeleteCommentVote_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            std::cout << "Vote deleted successfully\n";
        } else {
            std::cout << "Delete returned empty response\n";
        }
    } catch (const std::exception &e) {
        std::cerr << "Delete failed: " << e.what() << '\n';
    }
});

deleteDomainConfig

Parameters

Name	Type	Required	Description
tenantId	string	Yes
domain	string	Yes

Response

Returns: DeleteDomainConfig_200_response

Example

deleteDomainConfig Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domain = U("acme.com");
boost::optional<utility::string_t> correlationId = U("corr-456");
api->deleteDomainConfig(tenantId, domain)
.then([correlationId](std::shared_ptr<DeleteDomainConfig_200_response> resp){
    auto finalResp = resp ? resp : std::make_shared<DeleteDomainConfig_200_response>();
    (void)correlationId;
    (void)finalResp;
});

deleteFeedPostPublic

Parameters

Name	Type	Required
tenantId	string	Yes
postId	string	Yes
broadcastId	string	No
sso	string	No

Response

Returns: DeleteFeedPostPublic_200_response

Example

deleteFeedPostPublic Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t postId = U("post-9876");
boost::optional<utility::string_t> broadcastId = boost::optional<utility::string_t>(U("broadcast-42"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
auto placeholder = std::make_shared<DeleteFeedPostPublic_200_response>();
api->deleteFeedPostPublic(tenantId, postId, broadcastId, sso)
.then([&placeholder](pplx::task<std::shared_ptr<DeleteFeedPostPublic_200_response>> task) {
    try {
        placeholder = task.get();
        if (placeholder) std::cout << "Feed post deleted for tenant\n";
        else std::cout << "DeleteFeedPostPublic returned no content\n";
    } catch (const std::exception& e) {
        std::cerr << "Delete failed: " << e.what() << '\n';
    }
});

deletePage

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: DeletePageAPIResponse

Example

deletePage Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t pageId = U("page-456");
boost::optional<utility::string_t> requestTag = boost::none;
api->deletePage(tenantId, pageId)
.then([](std::shared_ptr<DeletePageAPIResponse> resp) {
    if (resp) {
        auto copy = std::make_shared<DeletePageAPIResponse>(*resp);
        (void)copy;
    }
}).wait();

deleteSSOUser

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
deleteComments	bool	No
commentDeleteMode	string	No

Response

Returns: DeleteSSOUserAPIResponse

Example

deleteSSOUser Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("user@example.com");
boost::optional<bool> deleteComments = boost::optional<bool>(true);
boost::optional<utility::string_t> commentDeleteMode = boost::optional<utility::string_t>(U("cascade"));
api->deleteSSOUser(tenantId, id, deleteComments, commentDeleteMode)
    .then([](std::shared_ptr<DeleteSSOUserAPIResponse> resp){
        if(!resp) return;
        auto resultCopy = std::make_shared<DeleteSSOUserAPIResponse>(*resp);
        (void)resultCopy;
    });

deleteSubscription

Parameters

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

Response

Returns: DeleteSubscriptionAPIResponse

Example

deleteSubscription Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t subscriptionId = U("sub-987654");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
api->deleteSubscription(tenantId, subscriptionId, userId)
.then([](pplx::task<std::shared_ptr<DeleteSubscriptionAPIResponse>> task) {
    try {
        auto resp = task.get();
        if (!resp) resp = std::make_shared<DeleteSubscriptionAPIResponse>();
        std::cout << "Subscription deleted for tenant\n";
    } catch (const std::exception& e) {
        std::cerr << "Error deleting subscription: " << e.what() << '\n';
    }
});

deleteUserBadge

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: UpdateUserBadge_200_response

Example

deleteUserBadge Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t badgeId = U("badge-abc123");
boost::optional<utility::string_t> maybeTenant = tenantId;
api->deleteUserBadge(maybeTenant.value(), badgeId)
.then([](pplx::task<std::shared_ptr<UpdateUserBadge_200_response>> prevTask){
    try {
        auto resp = prevTask.get();
        if (resp) return std::make_shared<UpdateUserBadge_200_response>(*resp);
        return std::make_shared<UpdateUserBadge_200_response>();
    } catch (...) {
        return std::make_shared<UpdateUserBadge_200_response>();
    }
});

flagComment

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
userId	string	No
anonUserId	string	No

Response

Returns: FlagComment_200_response

Example

flagComment Example

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
utility::string_t commentId = utility::conversions::to_string_t("cmt-456789");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(utility::conversions::to_string_t("user@example.com"));
boost::optional<utility::string_t> anonUserId = boost::optional<utility::string_t>(utility::conversions::to_string_t("anon-uuid-789"));
auto t = api->flagComment(tenantId, commentId, userId, anonUserId)
.then([](pplx::task<std::shared_ptr<FlagComment_200_response>> task){
    try {
        auto resp = task.get();
        auto marker = std::make_shared<utility::string_t>(utility::conversions::to_string_t("comment_flagged"));
        (void)resp;
        (void)marker;
    } catch (const std::exception&) {
    }
});

flagCommentPublic

Parameters

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

Response

Returns: FlagCommentPublic_200_response

Example

flagCommentPublic Example

Copy

boost::optional<utility::string_t> sso = utility::string_t(U("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.token"));
auto task = api->flagCommentPublic(utility::string_t(U("my-tenant-123")), utility::string_t(U("cmt-456")), true, sso)
    .then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
        try {
            auto resp = t.get();
            auto result = std::make_shared<FlagCommentPublic_200_response>(*resp);
            return result;
        } catch (const std::exception&) {
            return std::make_shared<FlagCommentPublic_200_response>();
        }
    });

getAuditLogs

Parameters

Name	Type	Required
tenantId	string	Yes
limit	double	No
skip	double	No
order	SORT_DIR	No
after	double	No
before	double	No

Response

Returns: GetAuditLogs_200_response

Example

getAuditLogs Example

Copy

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

getComment

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetComment_200_response

Example

getComment Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("comment-456");
boost::optional<utility::string_t> requestedBy = boost::optional<utility::string_t>(U("moderator@example.com"));
api->getComment(tenantId, commentId)
.then([](pplx::task<std::shared_ptr<GetComment_200_response>> task) {
    try {
        auto resp = task.get();
        if (resp) {
            auto copy = std::make_shared<GetComment_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

getComments

Parameters

Name	Type	Required
tenantId	string	Yes
page	int32_t	No
limit	int32_t	No
skip	int32_t	No
asTree	bool	No
skipChildren	int32_t	No
limitChildren	int32_t	No
maxTreeDepth	int32_t	No
urlId	string	No
userId	string	No
anonUserId	string	No
contextUserId	string	No
hashTag	string	No
parentId	string	No
direction	SortDirections	No

Response

Returns: GetComments_200_response

Example

getComments Example

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto page = boost::optional<int32_t>(1);
auto limit = boost::optional<int32_t>(25);
auto asTree = boost::optional<bool>(true);
auto maxDepth = boost::optional<int32_t>(3);
auto urlId = boost::optional<utility::string_t>(utility::string_t(U("/articles/2025/cpp-async")));
auto userId = boost::optional<utility::string_t>(utility::string_t(U("user@example.com")));
auto contextUserId = boost::optional<utility::string_t>(utility::string_t(U("ctx-user-42")));
auto direction = boost::optional<SortDirections>(SortDirections::DESC);
api->getComments(
    tenantId,
    page,
    limit,
    boost::optional<int32_t>(), 
    asTree,
    boost::optional<int32_t>(),
    boost::optional<int32_t>(),
    maxDepth,
    urlId,
    userId,
    boost::optional<utility::string_t>(),
    contextUserId,
    boost::optional<utility::string_t>(),
    boost::optional<utility::string_t>(),
    direction
).then([](std::shared_ptr<GetComments_200_response> resp){
    if (!resp) return;
    auto copy = std::make_shared<GetComments_200_response>(*resp);
});

getCommentsPublic

Parameters

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

Response

Returns: GetCommentsPublic_200_response

Example

getCommentsPublic Example

Copy

api->getCommentsPublic(
    utility::string_t(U("my-tenant-123")),
    utility::string_t(U("/articles/how-to-cpp-async")),
    boost::optional<int32_t>(1),
    boost::optional<SortDirections>(SortDirections::DESC)
).then([](pplx::task<std::shared_ptr<GetCommentsPublic_200_response>> t){
    try {
        auto resp = t.get();
        auto copy = std::make_shared<GetCommentsPublic_200_response>(*resp);
    } catch (...) {}
});

getCommentText

Parameters

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

Response

Returns: GetCommentText_200_response

Example

getCommentText Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654321");
boost::optional<utility::string_t> editKey = boost::optional<utility::string_t>(U("editkey-456"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-token-abc123"));
api->getCommentText(tenantId, commentId, editKey, sso)
.then([](pplx::task<std::shared_ptr<GetCommentText_200_response>> t){
    try {
        auto resp = t.get();
        auto safeResp = resp ? resp : std::make_shared<GetCommentText_200_response>();
    } catch (const std::exception &e) {
        auto fallback = std::make_shared<GetCommentText_200_response>();
    }
});

getCommentVoteUserNames

Parameters

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

Response

Returns: GetCommentVoteUserNames_200_response

Example

getCommentVoteUserNames Example

Copy

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

getDomainConfig

Parameters

Name	Type	Required	Description
tenantId	string	Yes
domain	string	Yes

Response

Returns: GetDomainConfig_200_response

Example

getDomainConfig Example

Copy

boost::optional<utility::string_t> tenantOpt = boost::optional<utility::string_t>(U("my-tenant-123"));
utility::string_t domain = U("blog.example.com");
api->getDomainConfig(*tenantOpt, domain)
    .then([=](std::shared_ptr<GetDomainConfig_200_response> resp){
        auto cfg = resp ? resp : std::make_shared<GetDomainConfig_200_response>();
        (void)cfg;
    });

getDomainConfigs

Parameters

Name	Type	Required	Description
tenantId	string	Yes

Response

Returns: GetDomainConfigs_200_response

Example

getDomainConfigs Example

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> environment = boost::optional<utility::string_t>(U("production"));
api->getDomainConfigs(tenantId).then([environment](std::shared_ptr<GetDomainConfigs_200_response> resp) -> pplx::task<std::shared_ptr<GetDomainConfigs_200_response>> {
    if (!resp) return pplx::task_from_result<std::shared_ptr<GetDomainConfigs_200_response>>(nullptr);
    auto resultCopy = std::make_shared<GetDomainConfigs_200_response>(*resp);
    return pplx::task_from_result(resultCopy);
});

getEventLog

Parameters

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

Response

Returns: GetEventLog_200_response

Example

getEventLog Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("post-789");
utility::string_t userIdWS = U("alice@example.com");
auto now = std::chrono::system_clock::now();
int64_t endTime = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
int64_t startTime = endTime - int64_t(24 * 60 * 60 * 1000);
boost::optional<std::shared_ptr<GetEventLog_200_response>> optResponse = std::make_shared<GetEventLog_200_response>();
api->getEventLog(tenantId, urlId, userIdWS, startTime, endTime)
    .then([&optResponse](pplx::task<std::shared_ptr<GetEventLog_200_response>> t) {
        try {
            auto resp = t.get();
            optResponse = resp ? resp : std::make_shared<GetEventLog_200_response>();
        } catch (...) {
            optResponse = std::make_shared<GetEventLog_200_response>();
        }
    });

getFeedPosts

Parameters

Name	Type	Required
tenantId	string	Yes
afterId	string	No
limit	int32_t	No
tags	vector<string	No

Response

Returns: GetFeedPosts_200_response

Example

getFeedPosts Example

Copy

utility::string_t tenantId("my-tenant-123");
boost::optional<utility::string_t> afterId(utility::string_t("post_98765"));
boost::optional<int32_t> limit(25);
std::vector<utility::string_t> tagVec{ utility::string_t("news"), utility::string_t("featured") };
boost::optional<std::vector<utility::string_t>> tags(tagVec);
api->getFeedPosts(tenantId, afterId, limit, tags).then([](pplx::task<std::shared_ptr<GetFeedPosts_200_response>> t) {
    try {
        auto resp = t.get();
        auto respCopy = std::make_shared<GetFeedPosts_200_response>(*resp);
        (void)respCopy;
    } catch (const std::exception& e) {
        (void)e;
    }
});

getFeedPostsPublic

Parameters

Name	Type	Required
tenantId	string	Yes
afterId	string	No
limit	int32_t	No
tags	vector<string	No
sso	string	No
isCrawler	bool	No
includeUserInfo	bool	No

Response

Returns: GetFeedPostsPublic_200_response

Example

getFeedPostsPublic Example

Copy

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

getFeedPostsStats

Parameters

Name	Type	Required
tenantId	string	Yes
postIds	vector<string	Yes
sso	string	No

Response

Returns: GetFeedPostsStats_200_response

Example

getFeedPostsStats Example

Copy

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

getGlobalEventLog

Parameters

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

Response

Returns: GetEventLog_200_response

Example

getGlobalEventLog Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("page-456");
utility::string_t userIdWS = U("user@example.com");
int64_t startTime = 1700000000000LL;
int64_t endTime = 1700003600000LL;
boost::optional<utility::string_t> optionalFilter = boost::none;
auto task = api->getGlobalEventLog(tenantId, urlId, userIdWS, startTime, endTime)
.then([](pplx::task<std::shared_ptr<GetEventLog_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto result = resp;
            (void)result;
        }
    } catch (const std::exception& e) {
        auto fallback = std::make_shared<GetEventLog_200_response>();
        (void)fallback;
    }
});

getPageByURLId

Parameters

Name	Type	Required	Description
tenantId	string	Yes
urlId	string	Yes

Response

Returns: GetPageByURLIdAPIResponse

Example

getPageByURLId Example

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> optUrlId = utility::conversions::to_string_t("page-9f8b7c6e");
auto reqTask = api->getPageByURLId(tenantId, *optUrlId)
    .then([](pplx::task<std::shared_ptr<GetPageByURLIdAPIResponse>> task)
    {
        try
        {
            auto resp = task.get();
            if (!resp) resp = std::make_shared<GetPageByURLIdAPIResponse>();
        }
        catch (const std::exception&)
        {
            auto resp = std::make_shared<GetPageByURLIdAPIResponse>();
        }
    });

getPages

Parameters

Name	Type	Required	Description
tenantId	string	Yes

Response

Returns: GetPagesAPIResponse

Example

getPages Example

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> pageToken = U("cursor_456");
auto pagesTask = api->getPages(tenantId).then([pageToken](pplx::task<std::shared_ptr<GetPagesAPIResponse>> t){
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<GetPagesAPIResponse>();
        return resp;
    } catch (...) {
        return std::make_shared<GetPagesAPIResponse>();
    }
});

getSSOUserByEmail

Parameters

Name	Type	Required	Description
tenantId	string	Yes
email	string	Yes

Response

Returns: GetSSOUserByEmailAPIResponse

Example

getSSOUserByEmail Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t email = U("user@example.com");
boost::optional<utility::string_t> emailOpt = email;
api->getSSOUserByEmail(tenantId, emailOpt.value()).then([](std::shared_ptr<GetSSOUserByEmailAPIResponse> resp) {
    auto safeResp = resp ? resp : std::make_shared<GetSSOUserByEmailAPIResponse>();
    std::cout << "SSO user fetch " << (resp ? "succeeded" : "failed") << std::endl;
}).wait();

getSSOUserById

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetSSOUserByIdAPIResponse

Example

getSSOUserById Example

Copy

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

getSSOUsers

Parameters

Name	Type	Required	Description
tenantId	string	Yes
skip	int32_t	No

Response

Returns: GetSSOUsers_200_response

Example

getSSOUsers Example

Copy

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

getSubscriptions

Parameters

Name	Type	Required	Description
tenantId	string	Yes
userId	string	No

Response

Returns: GetSubscriptionsAPIResponse

Example

getSubscriptions Example

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
auto fallback = std::make_shared<GetSubscriptionsAPIResponse>();
api->getSubscriptions(tenantId, userId)
    .then([fallback](std::shared_ptr<GetSubscriptionsAPIResponse> resp) {
        auto result = resp ? resp : fallback;
        return result;
    });

getUserBadge

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetUserBadge_200_response

Example

getUserBadge Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("alice@example.com");
boost::optional<utility::string_t> locale = boost::none;
auto defaultResp = std::make_shared<GetUserBadge_200_response>();
api->getUserBadge(tenantId, userId)
    .then([defaultResp](std::shared_ptr<GetUserBadge_200_response> resp) {
        auto result = resp ? resp : defaultResp;
        return result;
    })
    .then([](std::shared_ptr<GetUserBadge_200_response> finalResp) {
        if (finalResp) {
            std::cout << "User badge retrieved successfully\n";
        } else {
            std::cout << "Failed to retrieve user badge\n";
        }
    });

getUserBadgeProgressById

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetUserBadgeProgressById_200_response

Example

getUserBadgeProgressById Example

Copy

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

getUserBadgeProgressByUserId

Parameters

Name	Type	Required	Description
tenantId	string	Yes
userId	string	Yes

Response

Returns: GetUserBadgeProgressById_200_response

Example

getUserBadgeProgressByUserId Example

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
utility::string_t userId = utility::conversions::to_string_t("user@example.com");
boost::optional<utility::string_t> tenantOpt(tenantId);
boost::optional<utility::string_t> userOpt;
api->getUserBadgeProgressByUserId(tenantOpt.value_or(tenantId), userOpt.value_or(userId))
  .then([](pplx::task<std::shared_ptr<GetUserBadgeProgressById_200_response>> t){
    try {
      auto resp = t.get();
      if (!resp) resp = std::make_shared<GetUserBadgeProgressById_200_response>();
    } catch (const std::exception&) {}
  });

getUserBadgeProgressList

Parameters

Name	Type	Required
tenantId	string	Yes
userId	string	No
limit	double	No
skip	double	No

Response

Returns: GetUserBadgeProgressList_200_response

Example

getUserBadgeProgressList Example

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> userId(U("user@example.com"));
boost::optional<double> limit(25);
boost::optional<double> skip(0);
api->getUserBadgeProgressList(tenantId, userId, limit, skip)
.then([](pplx::task<std::shared_ptr<GetUserBadgeProgressList_200_response>> t)
{
    try {
        auto resp = t.get();
        return resp ? resp : std::make_shared<GetUserBadgeProgressList_200_response>();
    } catch(...) {
        return std::make_shared<GetUserBadgeProgressList_200_response>();
    }
});

getUserBadges

Parameters

Name	Type	Required
tenantId	string	Yes
userId	string	No
badgeId	string	No
type	double	No
displayedOnComments	bool	No
limit	double	No
skip	double	No

Response

Returns: GetUserBadges_200_response

Example

getUserBadges Example

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("alice@example.com"));
boost::optional<utility::string_t> badgeId = boost::optional<utility::string_t>(U("community-expert"));
boost::optional<double> type = boost::optional<double>(1.0);
boost::optional<bool> displayedOnComments = boost::optional<bool>(true);
boost::optional<double> limit = boost::optional<double>(20);
boost::optional<double> skip = boost::optional<double>(0);
auto ctx = std::make_shared<utility::string_t>(U("req-98765"));
api->getUserBadges(tenantId, userId, badgeId, type, displayedOnComments, limit, skip)
    .then([ctx](std::shared_ptr<GetUserBadges_200_response> resp){
        if (resp) {
            size_t marker = ctx->size();
            (void)marker;
        }
    }).wait();

getUserNotificationCount

Parameters

Name	Type	Required	Description
tenantId	string	Yes
sso	string	No

Response

Returns: GetUserNotificationCount_200_response

Example

getUserNotificationCount Example

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
api->getUserNotificationCount(tenantId, sso).then([](pplx::task<std::shared_ptr<GetUserNotificationCount_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            std::cout << "User notification count retrieved successfully" << std::endl;
        } else {
            std::cout << "No notification count returned" << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << "Failed to get notification count: " << e.what() << std::endl;
    }
});

getUserNotifications

Parameters

Name	Type	Required
tenantId	string	Yes
pageSize	int32_t	No
afterId	string	No
includeContext	bool	No
afterCreatedAt	int64_t	No
unreadOnly	bool	No
dmOnly	bool	No
noDm	bool	No
includeTranslations	bool	No
sso	string	No

Response

Returns: GetUserNotifications_200_response

Example

getUserNotifications Example

Copy

utility::string_t tenantId(U("my-tenant-123"));
boost::optional<int32_t> pageSize = 25;
boost::optional<utility::string_t> afterId = utility::string_t(U("notif_456"));
boost::optional<bool> includeContext = true;
boost::optional<int64_t> afterCreatedAt = 1625097600000LL;
boost::optional<bool> unreadOnly = true;
boost::optional<bool> dmOnly = false;
boost::optional<bool> noDm = false;
boost::optional<bool> includeTranslations = true;
boost::optional<utility::string_t> sso = utility::string_t(U("user@example.com"));
api->getUserNotifications(tenantId, pageSize, afterId, includeContext, afterCreatedAt, unreadOnly, dmOnly, noDm, includeTranslations, sso)
.then([](pplx::task<std::shared_ptr<GetUserNotifications_200_response>> t){
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<GetUserNotifications_200_response>();
        std::cout << "Notifications fetched\n";
    } catch (const std::exception &e) {
        std::cerr << "Failed: " << e.what() << '\n';
    }
});

getUserPresenceStatuses

Parameters

Name	Type	Required
tenantId	string	Yes
urlIdWS	string	Yes
userIds	string	Yes

Response

Returns: GetUserPresenceStatuses_200_response

Example

getUserPresenceStatuses Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlIdWS = U("wss://comments.fastcomments.com/ws/room-456");
boost::optional<utility::string_t> optUserIds = U("alice@example.com,bob@example.com");
utility::string_t userIds = optUserIds ? *optUserIds : utility::string_t();
api->getUserPresenceStatuses(tenantId, urlIdWS, userIds)
    .then([](pplx::task<std::shared_ptr<GetUserPresenceStatuses_200_response>> task){
        try {
            auto resp = task.get();
            if(!resp) resp = std::make_shared<GetUserPresenceStatuses_200_response>();
            // use resp as needed
        } catch (const std::exception&) {
            auto resp = std::make_shared<GetUserPresenceStatuses_200_response>();
        }
    });

getUserReactsPublic

Parameters

Name	Type	Required
tenantId	string	Yes
postIds	vector<string	No
sso	string	No

Response

Returns: GetUserReactsPublic_200_response

Example

getUserReactsPublic Example

Copy

utility::string_t tenantId = U("my-tenant-123");
std::vector<utility::string_t> postIdsVec = { U("post-abc-001"), U("post-def-002") };
boost::optional<std::vector<utility::string_t>> postIdsOpt = postIdsVec;
boost::optional<utility::string_t> ssoOpt = U("user@example.com");
auto fallback = std::make_shared<GetUserReactsPublic_200_response>();
api->getUserReactsPublic(tenantId, postIdsOpt, ssoOpt).then([fallback](std::shared_ptr<GetUserReactsPublic_200_response> resp){
    auto result = resp ? resp : fallback;
    std::wcout << U("Received user reacts (public)") << std::endl;
    return result;
});

lockComment

Parameters

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

Response

Returns: LockComment_200_response

Example

lockComment Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654");
utility::string_t broadcastId = U("broadcast-2025-11-20");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-token-abc123"));
api->lockComment(tenantId, commentId, broadcastId, sso)
.then([](pplx::task<std::shared_ptr<LockComment_200_response>> task){
    try {
        auto resp = task.get();
        if (!resp) resp = std::make_shared<LockComment_200_response>();
    } catch (const std::exception&) {
    }
});

patchDomainConfig

Parameters

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

Response

Returns: GetDomainConfig_200_response

Example

patchDomainConfig Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domainToUpdate = U("comments.example.com");
PatchDomainConfigParams patchParams;
patchParams.allowComments = boost::optional<bool>(true);
patchParams.moderationMode = boost::optional<utility::string_t>(U("pre-moderation"));
auto fallback = std::make_shared<GetDomainConfig_200_response>();
api->patchDomainConfig(tenantId, domainToUpdate, patchParams)
.then([fallback](pplx::task<std::shared_ptr<GetDomainConfig_200_response>> t)
{
    try
    {
        auto resp = t.get();
        if(!resp) resp = fallback;
        (void)resp;
    }
    catch(const std::exception &)
    {
        auto resp = fallback;
        (void)resp;
    }
});

patchPage

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateAPIPageData	UpdateAPIPageData	Yes

Response

Returns: PatchPageAPIResponse

Example

patchPage Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t pageId = U("page-987");
UpdateAPIPageData updateData;
updateData.title = boost::optional<utility::string_t>(U("Updated Comments Page"));
updateData.path = boost::optional<utility::string_t>(U("/products/widget-123/comments"));
updateData.isPublished = boost::optional<bool>(true);
api->patchPage(tenantId, pageId, updateData)
.then([](std::shared_ptr<PatchPageAPIResponse> resp) {
    if (resp) {
        auto updatedCopy = std::make_shared<PatchPageAPIResponse>(*resp);
    }
});

patchSSOUser

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateAPISSOUserData	UpdateAPISSOUserData	Yes
updateComments	bool	No

Response

Returns: PatchSSOUserAPIResponse

Example

patchSSOUser Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("user@example.com");
auto updatePtr = std::make_shared<UpdateAPISSOUserData>();
updatePtr->setEmail(U("user@example.com"));
updatePtr->setDisplayName(U("Jane Doe"));
boost::optional<bool> updateComments = boost::optional<bool>(true);
api->patchSSOUser(tenantId, id, *updatePtr, updateComments)
.then([](pplx::task<std::shared_ptr<PatchSSOUserAPIResponse>> task){
    try {
        auto resp = task.get();
        (void)resp;
    } catch (const std::exception &e) {
        (void)e;
    }
});

pinComment

Parameters

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

Response

Returns: PinComment_200_response

Example

pinComment Example

Copy

boost::optional<utility::string_t> sso(U("user@example.com"));
api->pinComment(U("my-tenant-123"), U("cmt-456"), U("broadcast-789"), sso)
.then([](pplx::task<std::shared_ptr<PinComment_200_response>> task){
    try {
        auto resp = task.get();
        auto result = resp ? resp : std::make_shared<PinComment_200_response>();
        std::cout << "pinComment completed successfully\n";
    } catch (const std::exception& e) {
        std::cerr << "pinComment failed: " << e.what() << '\n';
    }
});

putDomainConfig

Parameters

Name	Type	Required
tenantId	string	Yes
domainToUpdate	string	Yes
updateDomainConfigParams	UpdateDomainConfigParams	Yes

Response

Returns: GetDomainConfig_200_response

Example

putDomainConfig Example

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto domainToUpdate = utility::string_t(U("mydomain.com"));
auto updateParams = std::make_shared<UpdateDomainConfigParams>();
updateParams->enabled = true;
updateParams->contactEmail = boost::optional<utility::string_t>(U("admin@mydomain.com"));
updateParams->allowedOrigins = std::vector<utility::string_t>{ U("https://www.mydomain.com"), U("https://dashboard.mydomain.com") };
api->putDomainConfig(tenantId, domainToUpdate, *updateParams)
.then([](pplx::task<std::shared_ptr<GetDomainConfig_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            std::cout << "Domain config updated for tenant\n";
        }
    } catch (const std::exception& e) {
        std::cerr << "Failed to update domain config: " << e.what() << '\n';
    }
});

putSSOUser

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateAPISSOUserData	UpdateAPISSOUserData	Yes
updateComments	bool	No

Response

Returns: PutSSOUserAPIResponse

Example

putSSOUser Example

Copy

UpdateAPISSOUserData ssoData;
ssoData.email = utility::string_t("user@example.com");
ssoData.name = utility::string_t("Jane Doe");
boost::optional<bool> updateComments = true;
api->putSSOUser(utility::string_t("my-tenant-123"), utility::string_t("user@example.com"), ssoData, updateComments)
.then([](pplx::task<std::shared_ptr<PutSSOUserAPIResponse>> task){
    try {
        auto resp = task.get();
        auto result = resp ? std::make_shared<PutSSOUserAPIResponse>(*resp) : std::shared_ptr<PutSSOUserAPIResponse>();
        (void)result;
    } catch(const std::exception &e) {
        (void)e;
    }
});

reactFeedPostPublic

Parameters

Name	Type	Required
tenantId	string	Yes
postId	string	Yes
reactBodyParams	ReactBodyParams	Yes
isUndo	bool	No
broadcastId	string	No
sso	string	No

Response

Returns: ReactFeedPostPublic_200_response

Example

reactFeedPostPublic Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t postId = U("post-9876");
auto reactBodyPtr = std::make_shared<ReactBodyParams>();
boost::optional<bool> isUndo = false;
boost::optional<utility::string_t> broadcastId = U("broadcast-2025");
boost::optional<utility::string_t> sso = U("user@example.com");
api->reactFeedPostPublic(tenantId, postId, *reactBodyPtr, isUndo, broadcastId, sso)
.then([](std::shared_ptr<ReactFeedPostPublic_200_response> resp){
    (void)resp;
});

resetUserNotificationCount

Parameters

Name	Type	Required	Description
tenantId	string	Yes
sso	string	No

Response

Returns: ResetUserNotifications_200_response

Example

resetUserNotificationCount Example

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("user@example.com");
auto result = api->resetUserNotificationCount(tenantId, sso)
    .then([](std::shared_ptr<ResetUserNotifications_200_response> resp){
        if (!resp) resp = std::make_shared<ResetUserNotifications_200_response>();
        return resp;
    }).get();

resetUserNotifications

Parameters

Name	Type	Required
tenantId	string	Yes
afterId	string	No
afterCreatedAt	int64_t	No
unreadOnly	bool	No
dmOnly	bool	No
noDm	bool	No
sso	string	No

Response

Returns: ResetUserNotifications_200_response

Example

resetUserNotifications Example

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> afterId(utility::conversions::to_string_t("notification-987"));
boost::optional<int64_t> afterCreatedAt(1672531200LL);
boost::optional<bool> unreadOnly(true);
boost::optional<bool> dmOnly(false);
boost::optional<bool> noDm;
boost::optional<utility::string_t> sso(utility::conversions::to_string_t("sso-jwt-abc123"));
auto defaultResp = std::make_shared<ResetUserNotifications_200_response>();
api->resetUserNotifications(tenantId, afterId, afterCreatedAt, unreadOnly, dmOnly, noDm, sso)
.then([defaultResp](std::shared_ptr<ResetUserNotifications_200_response> resp){
    auto result = resp ? resp : defaultResp;
    (void)result;
});

saveComment

Parameters

Name	Type	Required
tenantId	string	Yes
createCommentParams	CreateCommentParams	Yes
isLive	bool	No
doSpamCheck	bool	No
sendEmails	bool	No
populateNotifications	bool	No

Response

Returns: SaveComment_200_response

Example

saveComment Example

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateCommentParams createParams;
createParams.body = U("This is a test comment from the C++ SDK");
createParams.authorEmail = U("user@example.com");
createParams.threadId = U("thread-456");
boost::optional<bool> isLive(true);
boost::optional<bool> doSpamCheck(false);
boost::optional<bool> sendEmails(true);
boost::optional<bool> populateNotifications(true);
api->saveComment(tenantId, createParams, isLive, doSpamCheck, sendEmails, populateNotifications)
.then([](pplx::task<std::shared_ptr<SaveComment_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto copy = std::make_shared<SaveComment_200_response>(*resp);
        }
    } catch (...) {
    }
});

searchUsers

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
usernameStartsWith	string	Yes
mentionGroupIds	vector<string	No
sso	string	No

Response

Returns: SearchUsers_200_response

Example

searchUsers Example

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
utility::string_t urlId = utility::conversions::to_string_t("article-456");
utility::string_t usernameStartsWith = utility::conversions::to_string_t("john");
boost::optional<std::vector<utility::string_t>> mentionGroupIds = std::vector<utility::string_t>{
    utility::conversions::to_string_t("editors"),
    utility::conversions::to_string_t("staff")
};
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("google");
api->searchUsers(tenantId, urlId, usernameStartsWith, mentionGroupIds, sso)
.then([](pplx::task<std::shared_ptr<SearchUsers_200_response>> task){
    try {
        auto resp = task.get();
        (void)resp;
    } catch (const std::exception& e) {
        auto fallback = std::make_shared<SearchUsers_200_response>();
        (void)fallback; (void)e;
    }
});

setCommentText

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
commentTextUpdateRequest	CommentTextUpdateRequest	Yes
editKey	string	No
sso	string	No

Response

Returns: SetCommentText_200_response

Example

setCommentText Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
utility::string_t broadcastId = U("broadcast-001");
CommentTextUpdateRequest req;
req.text = U("Thanks — updated comment text with additional context.");
boost::optional<utility::string_t> editKey = boost::optional<utility::string_t>(U("editKey-abc123"));
boost::optional<utility::string_t> sso = boost::none;
api->setCommentText(tenantId, commentId, broadcastId, req, editKey, sso)
.then([](std::shared_ptr<SetCommentText_200_response> resp){
    std::cout << "SetCommentText completed, response present: " << (resp ? "yes" : "no") << std::endl;
});

unBlockCommentPublic

Parameters

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

Response

Returns: UnBlockCommentPublic_200_response

Example

unBlockCommentPublic Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("comment-456");
PublicBlockFromCommentParams publicBlockFromCommentParams;
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(utility::string_t(U("sso-token-abc123")));
api->unBlockCommentPublic(tenantId, commentId, publicBlockFromCommentParams, sso)
.then([](pplx::task<std::shared_ptr<UnBlockCommentPublic_200_response>> t) {
    try {
        auto response = t.get();
        if (!response) {
            response = std::make_shared<UnBlockCommentPublic_200_response>();
        }
    } catch (const std::exception& e) {
    }
});

unBlockUserFromComment

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
unBlockFromCommentParams	UnBlockFromCommentParams	Yes
userId	string	No
anonUserId	string	No

Response

Returns: UnBlockCommentPublic_200_response

Example

unBlockUserFromComment Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("comment-789");
auto params = std::make_shared<UnBlockFromCommentParams>();
boost::optional<utility::string_t> userId(U("user@example.com"));
boost::optional<utility::string_t> anonUserId(U("anon-abc-123"));
api->unBlockUserFromComment(tenantId, id, *params, userId, anonUserId)
.then([](pplx::task<std::shared_ptr<UnBlockCommentPublic_200_response>> t){
    try {
        auto resp = t.get();
        (void)resp;
    } catch (const std::exception &e) {
        (void)e;
    }
});

unFlagComment

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
userId	string	No
anonUserId	string	No

Response

Returns: FlagComment_200_response

Example

unFlagComment Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<utility::string_t> anonUserId = boost::none;
auto task = api->unFlagComment(tenantId, commentId, userId, anonUserId)
    .then([](pplx::task<std::shared_ptr<FlagComment_200_response>> t){
        try {
            auto resp = t.get();
            auto finalResp = resp ? resp : std::make_shared<FlagComment_200_response>();
            (void)finalResp;
        } catch (const std::exception& e) {
            (void)e;
        }
    });

unLockComment

Parameters

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

Response

Returns: LockComment_200_response

Example

unLockComment Example

Copy

boost::optional<utility::string_t> sso(U("sso-token-abc123"));
api->unLockComment(U("my-tenant-123"), U("cmt-456"), U("broadcast-789"), sso)
.then([](pplx::task<std::shared_ptr<LockComment_200_response>> t){
    try {
        auto resp = t.get();
        auto result = resp ? resp : std::make_shared<LockComment_200_response>();
        (void)result;
    } catch (...) {
    }
});

unPinComment

Parameters

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

Response

Returns: PinComment_200_response

Example

unPinComment Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-98765");
utility::string_t broadcastId = U("broadcast-2025-11-20");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
api->unPinComment(tenantId, commentId, broadcastId, sso)
.then([](pplx::task<std::shared_ptr<PinComment_200_response>> task){
    try {
        auto resp = task.get();
        auto result = resp ? resp : std::make_shared<PinComment_200_response>();
        (void)result;
    } catch (const std::exception&) {
    }
});

updateComment

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updatableCommentParams	UpdatableCommentParams	Yes
contextUserId	string	No
doSpamCheck	bool	No
isLive	bool	No

Response

Returns: FlagCommentPublic_200_response

Example

updateComment Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
auto paramsPtr = std::make_shared<UpdatableCommentParams>();
paramsPtr->content = U("Clarified the point about API usage and fixed a typo.");
boost::optional<utility::string_t> contextUserId = U("moderator@example.com");
boost::optional<bool> doSpamCheck = true;
boost::optional<bool> isLive = false;
api->updateComment(tenantId, commentId, *paramsPtr, contextUserId, doSpamCheck, isLive)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) std::cout << "Comment updated successfully\n";
        else std::cout << "No response received\n";
    } catch (const std::exception &e) {
        std::cerr << "Update failed: " << e.what() << std::endl;
    }
});

updateFeedPost

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
feedPost	FeedPost	Yes

Response

Returns: FlagCommentPublic_200_response

Example

updateFeedPost Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t postId = U("post-456");
FeedPost feedPost;
feedPost.title = U("Scheduled maintenance");
feedPost.content = U("We'll be updating servers at 00:00 UTC.");
feedPost.authorEmail = U("admin@my-domain.com");
feedPost.authorDisplayName = boost::optional<utility::string_t>(U("Site Admin"));
feedPost.pinned = boost::optional<bool>(false);
api->updateFeedPost(tenantId, postId, feedPost)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
    try {
        auto resp = t.get();
        auto safeResp = resp ? resp : std::make_shared<FlagCommentPublic_200_response>();
        if (safeResp) std::cout << "Feed post updated successfully\n";
        else std::cout << "Update returned empty response\n";
    } catch (const std::exception &e) {
        std::cerr << "Update failed: " << e.what() << '\n';
    }
});

updateFeedPostPublic

Parameters

Name	Type	Required
tenantId	string	Yes
postId	string	Yes
updateFeedPostParams	UpdateFeedPostParams	Yes
broadcastId	string	No
sso	string	No

Response

Returns: CreateFeedPostPublic_200_response

Example

updateFeedPostPublic Example

Copy

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

updateUserBadge

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateUserBadgeParams	UpdateUserBadgeParams	Yes

Response

Returns: UpdateUserBadge_200_response

Example

updateUserBadge Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("user-9876");
auto paramsPtr = std::make_shared<UpdateUserBadgeParams>();
paramsPtr->name = utility::string_t(U("Community Moderator"));
paramsPtr->color = utility::string_t(U("#4CAF50"));
boost::optional<utility::string_t> note = boost::optional<utility::string_t>(U("Recognized contributor"));
paramsPtr->note = note;
paramsPtr->active = true;
api->updateUserBadge(tenantId, id, *paramsPtr)
    .then([](pplx::task<std::shared_ptr<UpdateUserBadge_200_response>> task) {
        try {
            auto resp = task.get();
            (void)resp;
        } catch (...) {
        }
    });

updateUserNotificationCommentSubscriptionStatus

Parameters

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

Response

Returns: UpdateUserNotificationStatus_200_response

Example

updateUserNotificationCommentSubscriptionStatus Example

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
utility::string_t notificationId = utility::conversions::to_string_t("notif-456");
utility::string_t optedInOrOut = utility::conversions::to_string_t("opted_in");
utility::string_t commentId = utility::conversions::to_string_t("comment-789");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(utility::conversions::to_string_t("sso-jwt-token-abc123"));
api->updateUserNotificationCommentSubscriptionStatus(tenantId, notificationId, optedInOrOut, commentId, sso)
.then([](pplx::task<std::shared_ptr<UpdateUserNotificationStatus_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) std::cout << "Subscription updated successfully\n";
        else std::cout << "No response\n";
    } catch (const std::exception& e) {
        std::cout << "Error: " << e.what() << '\n';
    }
});

updateUserNotificationPageSubscriptionStatus

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
url	string	Yes
pageTitle	string	Yes
subscribedOrUnsubscribed	string	Yes
sso	string	No

Response

Returns: UpdateUserNotificationStatus_200_response

Example

updateUserNotificationPageSubscriptionStatus Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("page-456");
utility::string_t url = U("https://www.example.com/articles/fastcomments-integration");
utility::string_t pageTitle = U("FastComments Integration Guide");
utility::string_t subscribedOrUnsubscribed = U("subscribed");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-token-74a9"));
api->updateUserNotificationPageSubscriptionStatus(tenantId, urlId, url, pageTitle, subscribedOrUnsubscribed, sso)
    .then([](pplx::task<std::shared_ptr<UpdateUserNotificationStatus_200_response>> task){
        try {
            auto resp = task.get();
            if (!resp) {
                auto fallback = std::make_shared<UpdateUserNotificationStatus_200_response>();
                (void)fallback;
            } else {
                (void)resp;
            }
        } catch (const std::exception& e) {
            (void)e;
        }
    });

updateUserNotificationStatus

Parameters

Name	Type	Required
tenantId	string	Yes
notificationId	string	Yes
newStatus	string	Yes
sso	string	No

Response

Returns: UpdateUserNotificationStatus_200_response

Example

updateUserNotificationStatus Example

Copy

utility::string_t tenantId = utility::string_t("my-tenant-123");
utility::string_t notificationId = utility::string_t("notif-98765");
utility::string_t newStatus = utility::string_t("read");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(utility::string_t("user@example.com"));
api->updateUserNotificationStatus(tenantId, notificationId, newStatus, sso)
.then([](pplx::task<std::shared_ptr<UpdateUserNotificationStatus_200_response>> task) {
    try {
        auto resp = task.get();
        auto safeResp = resp ? resp : std::make_shared<UpdateUserNotificationStatus_200_response>();
        (void)safeResp;
    } catch (...) {
    }
}).wait();

uploadImage

Parameters

Name	Type	Required
tenantId	string	Yes
file	HttpContent	Yes
sizePreset	SizePreset	No
urlId	string	No

Response

Returns: UploadImageResponse

Example

uploadImage Example

Copy

utility::string_t tenantId = U("my-tenant-123");
auto fileContent = std::make_shared<HttpContent>(U("avatar.png"), U("image/png"));
boost::optional<SizePreset> sizePreset = boost::optional<SizePreset>(SizePreset::MEDIUM);
boost::optional<utility::string_t> urlId = boost::optional<utility::string_t>(U("profile-avatar"));
api->uploadImage(tenantId, *fileContent, sizePreset, urlId)
.then([](std::shared_ptr<UploadImageResponse> resp){
    if (resp) std::cout << "Image uploaded successfully" << std::endl;
    else std::cerr << "Image upload returned no response" << std::endl;
});

voteComment

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
voteBodyParams	VoteBodyParams	Yes
sessionId	string	No
sso	string	No

Response

Returns: VoteComment_200_response

Example

voteComment Example

Copy

VoteBodyParams voteBodyParams;
boost::optional<utility::string_t> sessionId(U("sess-7f8e-7a9b"));
boost::optional<utility::string_t> sso(U("user@example.com"));
api->voteComment(U("my-tenant-123"), U("cmt-98765"), U("url-456"), U("br-222"), voteBodyParams, sessionId, sso)
.then([](pplx::task<std::shared_ptr<VoteComment_200_response>> task){
    try {
        auto resp = task.get();
        auto ack = std::make_shared<utility::string_t>(U("vote-recorded"));
        (void)ack;
    } catch(...) {
    }
});

Need Help?

If you encounter any issues or have questions about the C++ SDK, please:

Contributing

Contributions are welcome! Please visit the GitHub repository for contribution guidelines.

Documentation

Getting Started

API Reference

Usage

API

FastComments C++ SDK

Repository

Requirements

Installation

Install Dependencies

Building from Source

Installing

Library Contents

Public vs Secured APIs

Quick Start

Using Authenticated APIs (DefaultAPI)

Using Public APIs (PublicAPI)

Common Issues

Making API Calls: Synchronous vs Asynchronous

Synchronous Calls with .get()

Asynchronous Calls with .then()

Choosing Between Synchronous and Asynchronous

Notes

Broadcast Ids

SSO (Single Sign-On)

SSO Usage

Simple SSO

Secure SSO

Testing

Development

Support

Documentation for fastcomments

Documentation for fastcomments

Documentation for API Endpoints

Documentation for Models

Documentation for Authorization

api_key

addDomainConfig

Parameters

Response

Example

addPage

Parameters

Response

Example

addSSOUser

Parameters

Response

Example

aggregate

Parameters

Response

Example

aggregateQuestionResults

Parameters

Response

Example

blockFromCommentPublic

Parameters

Response

Example

blockUserFromComment

Parameters

Response

Example

bulkAggregateQuestionResults

Parameters

Response

Example

checkedCommentsForBlocked

Parameters

Response

Example

combineCommentsWithQuestionResults

Parameters

Response

Example

createCommentPublic

Parameters

Response

Synchronous Calls with `.get()`

Asynchronous Calls with `.then()`