FastComments C++ SDK

Това е официалното C++ SDK за FastComments.

Официално C++ SDK за FastComments API

Репозитория

Изисквания

C++17 или по-нова версия
CMake 3.14 или по-нова версия
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (автоматично се изтегля за тестване)

Инсталиране

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

Тази библиотека съдържа генерирания API клиент и SSO инструментите, които улесняват работата с API-то.

API Client Library Docs

Public vs Secured APIs

За API клиента има три класа, DefaultApi, PublicApi и ModerationApi. DefaultApi съдържа методи, които изискват вашия API ключ, а PublicApi съдържа методи, които могат да бъдат извикани директно от браузър/мобилно устройство и т.н. без автентикация. ModerationApi предоставя обширен набор от живи и бързи API за модериране. Всеки метод на ModerationApi приема параметър sso и може да се автентицира чрез SSO или бисквитка за сесия от FastComments.com.

Бърз старт

Using Authenticated APIs (DefaultAPI)

Important:

Трябва да зададете базовия URL (генераторът cpp-restsdk не го чете от OpenAPI спецификацията)
Трябва да зададете вашия API ключ на ApiClient преди да правите автентифицирани заявки. Ако не го направите, заявките ще се провалят с грешка 401.

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

Using Moderation APIs (ModerationApi)

The ModerationApi powers the moderator dashboard. Every method accepts an sso parameter so the call runs on behalf of an SSO-authenticated moderator (see the SSO section below for how to create a token):

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

Common Issues

"URI must contain a hostname" error: Уверете се, че извиквате config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) преди да създадете ApiClient. Генераторът cpp-restsdk автоматично не чете URL на сървъра от OpenAPI спецификацията.
401 "missing-api-key" error: Уверете се, че извиквате config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) преди да създадете инстанция на DefaultAPI.
Wrong API class: Използвайте DefaultApi за сървърни автентифицирани заявки, PublicApi за клиентски/публични заявки и ModerationApi за заявки към таблото за модератори (автентифицирани с модераторски SSO токен).

Извикване на API: Синхронно срещу Асинхронно

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

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

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

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

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

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

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

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

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.

Забележки

Идентификатори на излъчване

Ще видите, че трябва да подадете broadcastId в някои API повиквания. Когато получавате събития, ще получите този идентификатор обратно, така че да знаете да игнорирате събитието, ако планирате да приложите промените оптимистично на клиента (което вероятно ще искате да направите, тъй като това осигурява най-доброто изживяване). Подайте UUID тук. Идентификаторът трябва да бъде достатъчно уникален, за да не се появи два пъти в една браузърна сесия.

SSO (Единно влизане)

За примери за SSO вижте по-долу.

Използване на SSO

Просто 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;
}

Сигурно 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;
}

Документация за fastcomments

Документация за API крайни точки

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

Клас	Метод	HTTP заявка	Описание
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	Агрегира документи чрез групиране (ако се предостави `groupBy`) и прилагане на множество операции. Поддържат се различни операции (например sum, countDistinct, avg и др.).
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	изисква 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}	изисква tenantId urlId
PublicApi	getEventLog	GET /event-log/{tenantId}	изисква tenantId urlId userIdWS
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	изисква 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}	изисква tenantId urlId userIdWS
PublicApi	getOfflineUsers	GET /pages/{tenantId}/users/offline	Предишни коментатори на страницата, които НЕ са онлайн в момента. Подреждане по displayName. Използвайте след като изчерпате /users/online, за да визуализирате раздел „Members“. Курсорна пагинация по commenterName: сървърът обходва частичния {tenantId, urlId, commenterName} индекс след afterName чрез $gt, без разход за $skip.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	Профили на потребители, които в момента са онлайн на страницата: хора, чието websocket сесия е абонирана за страницата в момента. Връща anonCount + totalCount (абонати за стаята, включително анонимни зрители, които не се изброяват).
PublicApi	getPagesPublic	GET /pages/{tenantId}	Списък с страниците за даден наемател. Използва се от настолен клиент FChat за попълване на списъка със стаи. Изисква `enableFChat` да бъде true в резолвнатата потребителска конфигурация за всяка страница. Страници, които изискват SSO, се филтрират спрямо груповия достъп на заявилия потребител.
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	Масивна информация за потребителите за даден наемател. При зададени userIds се връща информация за показване от User / SSOUser. Използва се от widget-а за коментари, за да обогати потребителите, които току‑що се появяват чрез събитие за присъствие. Без контекст на страницата: поверителността се прилага еднозначно (частни профили се маскират).
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}	Активира или деактивира известия за конкретен коментар.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Активира или деактивира известия за страница. Когато потребителите се абонират за страница, се създават известия за нови коренови коментари, и също …
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Качване и преоразмеряване на изображение
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Документация за модели

Агрегиране

Агрегира документи чрез групиране (ако се предостави groupBy) и прилагане на множество операции.
Поддържат се различни операции (напр. sum, countDistinct, avg и др.).

Параметри

Име	Тип	Задължително
tenantId	string	Yes
aggregationRequest	AggregationRequest	Yes
options	const AggregateOptions&	Yes

Отговор

Връща: AggregateResponse

Пример

Пример за агрегиране

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();
            // обработи отговора
        } catch (const std::exception& e) {
            // обработи грешка
        }
    });

Вземи одитни записи

Parameters

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetAuditLogsOptions&	Да

Response

Връща: GetAuditLogsResponse

Example

getAuditLogs Пример

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();
        // използвайте отговора
    } catch (const std::exception& e) {
        // обработете грешката
    }
});

Излизане (публично)

Отговор

Връща: APIEmptyResponse

Пример

Пример за logoutPublic

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

Блокирай по коментар (публично)

Параметри

Име	Тип	Задължително
tenantId	string	Да
commentId	string	Да
publicBlockFromCommentParams	PublicBlockFromCommentParams	Да
sso	string	Не

Отговор

Връща: BlockSuccess

Пример

blockFromCommentPublic Пример

Copy

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

Премахни блокиране на коментар (публично)

Параметри

Име	Тип	Задължително
tenantId	string	Да
commentId	string	Да
publicBlockFromCommentParams	PublicBlockFromCommentParams	Да
sso	string	Не

Отговор

Връща: UnblockSuccess

Пример

unBlockCommentPublic Пример

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

Проверка за блокирани коментари

Параметри

Име	Тип	Задължително
tenantId	string	Да
commentIds	string	Да
sso	string	Не

Отговор

Връща: CheckBlockedCommentsResponse

Пример

checkedCommentsForBlocked Пример

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

Блокирай потребител от коментар

Parameters

Име	Тип	Задължително
tenantId	string	Да
id	string	Да
blockFromCommentParams	BlockFromCommentParams	Да
options	const BlockUserFromCommentOptions&	Да

Отговор

Връща: BlockSuccess

Пример

blockUserFromComment пример

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

Създай коментар (публично)

Параметри

Име	Тип	Задължително
tenantId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
commentData	CommentData	Yes
options	const CreateCommentPublicOptions&	Yes

Отговор

Връща: SaveCommentsResponseWithPresence

Пример

createCommentPublic Пример

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

Изтрий коментар

Параметри

Име	Тип	Задължително
tenantId	string	Да
id	string	Да
options	const DeleteCommentOptions&	Да

Отговор

Връща: DeleteCommentResult

Пример

Пример за deleteComment

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

Изтрий коментар (публично)

Параметри

Име	Тип	Задължително
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
options	const DeleteCommentPublicOptions&	Yes

Отговор

Връща: PublicAPIDeleteCommentResponse

Пример

deleteCommentPublic Пример

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

Изтрий глас за коментар

Параметри

Име	Тип	Задължително
tenantId	string	Да
commentId	string	Да
voteId	string	Да
urlId	string	Да
broadcastId	string	Да
options	const DeleteCommentVoteOptions&	Да

Отговор

Връща: VoteDeleteResponse

Пример

deleteCommentVote Пример

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

Маркирай коментар

Параметри

Име	Тип	Задължително
tenantId	string	Да
id	string	Да
options	const FlagCommentOptions&	Да

Отговор

Връща: FlagCommentResponse

Пример

Пример за flagComment

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

Вземи коментар

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
id	string	Да

Отговор

Връща: APIGetCommentResponse

Пример

Пример за getComment

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

Вземи коментари

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
options	const GetCommentsOptions&	Yes

Отговор

Връща: APIGetCommentsResponse

Пример

Пример getComments

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();
        // използвайте отговора по необходимост
    } catch (const std::exception& e) {
        // обработете грешката
    }
});

Вземи коментари (публично)

req tenantId urlId

Параметри

Име	Тип	Задължително
tenantId	string	Yes
urlId	string	Yes
options	const GetCommentsPublicOptions&	Yes

Отговор

Връща: GetCommentsResponseWithPresence_PublicComment_

Пример

getCommentsPublic Пример

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

Вземи текст на коментар

Параметри

Име	Тип	Задължително
tenantId	string	Yes
commentId	string	Yes
options	const GetCommentTextOptions&	Yes

Отговор

Връща: PublicAPIGetCommentTextResponse

Пример

getCommentText Пример

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

Вземи имена на потребители, гласували за коментар

Параметри

Име	Тип	Задължително
tenantId	string	Yes
commentId	string	Yes
dir	int32_t	Yes
sso	string	No

Отговор

Връща: GetCommentVoteUserNamesSuccessResponse

Пример

Пример за getCommentVoteUserNames

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

Заключи коментар

Параметри

Име	Тип	Задължително
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Отговор

Връща: APIEmptyResponse

Пример

Пример за lockComment

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

Закачи коментар

Параметри

Име	Тип	Задължително
tenantId	string	Да
commentId	string	Да
broadcastId	string	Да
sso	string	Не

Отговор

Връща: ChangeCommentPinStatusResponse

Пример

Пример за pinComment

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

Запази коментар

Параметри

Име	Тип	Задължително
tenantId	string	Yes
createCommentParams	CreateCommentParams	Yes
options	const SaveCommentOptions&	Yes

Отговор

Връща: APISaveCommentResponse

Пример

пример за saveComment

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

Задай текст на коментар

Параметри

Име	Тип	Задължително
tenantId	string	Да
commentId	string	Да
broadcastId	string	Да
commentTextUpdateRequest	CommentTextUpdateRequest	Да
options	const SetCommentTextOptions&	Да

Отговор

Връща: PublicAPISetCommentTextResponse

Пример

setCommentText Пример

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

Разблокирай потребител от коментар

Параметри

Име	Тип	Задължително
tenantId	string	Yes
id	string	Yes
unBlockFromCommentParams	UnBlockFromCommentParams	Yes
options	const UnBlockUserFromCommentOptions&	Yes

Отговор

Връща: UnblockSuccess

Пример

unBlockUserFromComment Пример

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

Премахни маркировка на коментар

Параметри

Име	Тип	Задължително
tenantId	string	Да
id	string	Да
options	const UnFlagCommentOptions&	Да

Отговор

Връща: FlagCommentResponse

Пример

unFlagComment Пример

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;
            // обработете статуса, ако е необходимо
        }
    })
    .then([](pplx::task<void> previous) {
        try {
            previous.get();
        } catch (const std::exception& e) {
            // обработете грешката
        }
    });

Отключи коментар

Параметри

Име	Тип	Задължително
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Отговор

Връща: APIEmptyResponse

Пример

Пример за unLockComment

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, sss).then([](pplx::task<std::shared_ptr<APIEmptyResponse>> task) {
    try {
        auto response = task.get();
    } catch (const std::exception&) {
    }
});

Откачи коментар

Параметри

Име	Тип	Задължително
tenantId	string	Да
commentId	string	Да
broadcastId	string	Да
sso	string	Не

Отговор

Връща: ChangeCommentPinStatusResponse

Пример

Пример за unPinComment

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

Обнови коментар

Параметри

Име	Тип	Задължително
tenantId	string	Yes
id	string	Yes
updatableCommentParams	UpdatableCommentParams	Yes
options	const UpdateCommentOptions&	Yes

Отговор

Връща: APIEmptyResponse

Пример

Пример за updateComment

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

Гласувай за коментар

Параметри

Име	Тип	Задължително
tenantId	string	Да
commentId	string	Да
urlId	string	Да
broadcastId	string	Да
voteBodyParams	VoteBodyParams	Да
options	const VoteCommentOptions&	Да

Отговор

Връща: VoteResponse

Пример

Пример за voteComment

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();
           // обработка на отговора
       } catch (const std::exception&) {
       }
   });

Вземи коментари за потребител

Параметри

Name	Type	Required	Description
options	const GetCommentsForUserOptions&	Yes

Отговор

Връща: GetCommentsForUserResponse

Пример

Пример за getCommentsForUser

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

Добави конфигурация на домейн

Parameters

Име	Тип	Задължително	Описание
tenantId	string	Да
addDomainConfigParams	AddDomainConfigParams	Да

Response

Връща: AddDomainConfigResponse

Example

addDomainConfig Пример

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

Изтрий конфигурация на домейн

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
domain	string	Yes

Отговор

Връща: DeleteDomainConfigResponse

Пример

deleteDomainConfig Пример

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

Вземи конфигурация на домейн

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
domain	string	Да

Отговор

Връща: GetDomainConfigResponse

Пример

Пример за getDomainConfig

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) {
            // обработка на активирана модерация
        }
        if (theme) {
            // използване на стойността на темата
        }
    })
    .wait();

Вземи конфигурации на домейн

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да

Отговор

Връща: GetDomainConfigsResponse

Пример

Пример за getDomainConfigs

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

Частично обнови конфигурация на домейн

Параметри

Име	Тип	Задължителен
tenantId	string	Да
domainToUpdate	string	Да
patchDomainConfigParams	PatchDomainConfigParams	Да

Отговор

Връща: PatchDomainConfigResponse

Пример

patchDomainConfig Пример

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) {
        // успешно обработване
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* обработка на грешка */ }
    });

Задай конфигурация на домейн (PUT)

Параметри

Име	Тип	Задължително
tenantId	string	Yes
domainToUpdate	string	Yes
updateDomainConfigParams	UpdateDomainConfigParams	Yes

Отговор

Връща: PutDomainConfigResponse

Пример

putDomainConfig Пример

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

Създай имейл шаблон

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
createEmailTemplateBody	CreateEmailTemplateBody	Да

Отговор

Връща: CreateEmailTemplateResponse

Пример

createEmailTemplate Пример

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

Изтрий имейл шаблон

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
id	string	Да

Отговор

Връща: APIEmptyResponse

Пример

deleteEmailTemplate Пример

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

Изтрий грешка при рендер на имейл шаблон

Параметри

Име	Тип	Задължително
tenantId	string	Yes
id	string	Yes
errorId	string	Yes

Отговор

Връща: APIEmptyResponse

Пример

Пример за deleteEmailTemplateRenderError

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

Вземи имейл шаблон

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
id	string	Да

Отговор

Връща: GetEmailTemplateResponse

Пример

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

Вземи дефиниции на имейл шаблони

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да

Отговор

Връща: GetEmailTemplateDefinitionsResponse

Пример

Пример за getEmailTemplateDefinitions

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

Вземи грешки при рендер на имейл шаблони

Параметри

Име	Тип	Задължително
tenantId	string	Yes
id	string	Yes
skip	double	No

Отговор

Връща: GetEmailTemplateRenderErrorsResponse

Пример

Пример за getEmailTemplateRenderErrors

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();
            // Използвайте отговора според нужда
        } catch (const std::exception& ex) {
            // Обработете грешката
        }
    });

Вземи имейл шаблони

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
skip	double	Не

Отговор

Връща: GetEmailTemplatesResponse

Пример

getEmailTemplates Пример

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

Рендерирай имейл шаблон

Параметри

Име	Тип	Задължително
tenantId	string	Да
renderEmailTemplateBody	RenderEmailTemplateBody	Да
locale	string	Не

Отговор

Връща: RenderEmailTemplateResponse

Пример

Пример за renderEmailTemplate

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

Обнови имейл шаблон

Параметри

Име	Тип	Задължително
tenantId	string	Да
id	string	Да
updateEmailTemplateBody	UpdateEmailTemplateBody	Да

Отговор

Връща: APIEmptyResponse

Пример

Пример за updateEmailTemplate

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) {
        // обработка при успех
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception &) { /* обработка на грешка */ }
    });

Вземи регистър на събития

req tenantId urlId userIdWS

Параметри

Име	Тип	Задължително
tenantId	string	Yes
urlId	string	Yes
userIdWS	string	Yes
startTime	int64_t	Yes
endTime	int64_t	No

Отговор

Връща: GetEventLogResponse

Пример

getEventLog Пример

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

Вземи глобален регистър на събития

req tenantId urlId userIdWS

Параметри

Име	Тип	Задължителен
tenantId	string	Да
urlId	string	Да
userIdWS	string	Да
startTime	int64_t	Да
endTime	int64_t	Не

Отговор

Връща: GetEventLogResponse

Пример

Пример за getGlobalEventLog

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

Създай публикация във фийда

Параметри

Име	Тип	Задължително
tenantId	string	Да
createFeedPostParams	CreateFeedPostParams	Да
options	const CreateFeedPostOptions&	Да

Отговор

Връща: CreateFeedPostsResponse

Пример

createFeedPost Пример

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

Създай публикация във фийда (публично)

Параметри

Име	Тип	Задължително
tenantId	string	Да
createFeedPostParams	CreateFeedPostParams	Да
options	const CreateFeedPostPublicOptions&	Да

Отговор

Връща: CreateFeedPostResponse

Пример

createFeedPostPublic Пример

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

Изтрий публикация във фийда (публично)

Параметри

Име	Тип	Задължителен
tenantId	string	Да
postId	string	Да
options	const DeleteFeedPostPublicOptions&	Да

Отговор

Връща: DeleteFeedPostPublicResponse

Пример

Пример за deleteFeedPostPublic

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()) {
            // логика за успех
        }
    });

Вземи публикации във фийда

req tenantId afterId

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetFeedPostsOptions&	Да

Отговор

Връща: GetFeedPostsResponse

Пример

getFeedPosts Пример

Copy

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

Вземи публикации във фийда (публично)

req tenantId afterId

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
options	const GetFeedPostsPublicOptions&	Yes

Отговор

Връща: PublicFeedPostsResponse

Пример

Пример за getFeedPostsPublic

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);
        // Използвайте processed, както е необходимо
    }catch(const std::exception&){
        // Обработете грешката
    }
});

Вземи статистики за публикации във фийда

Параметри

Име	Тип	Задължително
tenantId	string	Yes
postIds	vector<string	Yes
sso	string	No

Отговор

Връща: FeedPostsStatsResponse

Пример

Пример за 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;
    });

Вземи реакции на потребителя (публично)

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetUserReactsPublicOptions&	Да

Отговор

Връща: UserReactsResponse

Пример

Пример за getUserReactsPublic

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

Реагирай на публикация във фийда (публично)

Параметри

Име	Тип	Задължително
tenantId	string	Да
postId	string	Да
reactBodyParams	ReactBodyParams	Да
options	const ReactFeedPostPublicOptions&	Да

Отговор

Връща: ReactFeedPostResponse

Пример

reactFeedPostPublic Пример

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

Обнови публикация във фийда

Параметри

Име	Тип	Задължително
tenantId	string	Yes
id	string	Yes
feedPost	FeedPost	Yes

Отговор

Връща: APIEmptyResponse

Пример

Пример за updateFeedPost

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

Обнови публикация във фийда (публично)

Параметри

Име	Тип	Задължително
tenantId	string	Yes
postId	string	Yes
updateFeedPostParams	UpdateFeedPostParams	Yes
options	const UpdateFeedPostPublicOptions&	Yes

Отговор

Връща: CreateFeedPostResponse

Пример

Пример за updateFeedPostPublic

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

Маркирай коментар (публично)

Параметри

Име	Тип	Задължително
tenantId	string	Yes
commentId	string	Yes
isFlagged	bool	Yes
sso	string	No

Отговор

Връща: APIEmptyResponse

Пример

Пример за flagCommentPublic

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

Вземи голям GIF

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
largeInternalURLSanitized	string	Yes

Отговор

Връща: GifGetLargeResponse

Пример

Пример за getGifLarge

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

Търси GIF-ове

Параметри

Име	Тип	Задължително
tenantId	string	Да
search	string	Да
options	const GetGifsSearchOptions&	Да

Отговор

Връща: GetGifsSearchResponse

Пример

Пример за getGifsSearch

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

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetGifsTrendingOptions&	Да

Отговор

Връща: GetGifsTrendingResponse

Пример

Пример за getGifsTrending

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

Добави хаштаг

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
createHashTagBody	CreateHashTagBody	Да

Отговор

Връща: CreateHashTagResponse

Пример

addHashTag Пример

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

Добави хаштагове масово

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Да

Отговор

Връща: BulkCreateHashTagsResponse

Пример

addHashTagsBulk Пример

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

Изтрий хаштаг

Параметри

Име	Тип	Задължително
tenantId	string	Yes
tag	string	Yes
deleteHashTagRequestBody	DeleteHashTagRequestBody	Yes

Отговор

Връща: APIEmptyResponse

Пример

Пример за deleteHashTag

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

Вземи хаштагове

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
page	double	Не

Отговор

Връща: GetHashTagsResponse

Пример

getHashTags Пример

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);
        // use response
    } catch (const std::exception&) {
        // handle error
    }
});

Частично обнови хаштаг

Параметри

Име	Тип	Задължително
tenantId	string	Да
tag	string	Да
updateHashTagBody	UpdateHashTagBody	Да

Отговор

Връща: UpdateHashTagResponse

Пример

Пример за patchHashTag

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

Изтрий глас за модериране

Параметри

Име	Тип	Задължително
tenantId	string	Да
commentId	string	Да
voteId	string	Да
options	const DeleteModerationVoteOptions&	Да

Отговор

Връща: VoteDeleteResponse

Пример

Пример за deleteModerationVote

Copy

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

Вземи API коментари

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
options	const GetApiCommentsOptions&	Yes

Отговор

Връща: ModerationAPIGetCommentsResponse

Пример

Пример за 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&){
    }
});

Вземи статус на API експорт

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetApiExportStatusOptions&	Да

Отговор

Връща: ModerationExportStatusResponse

Пример

Пример за getApiExportStatus

Copy

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

Вземи API идентификатори

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetApiIdsOptions&	Да

Отговор

Връща: ModerationAPIGetCommentIdsResponse

Пример

Пример за 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&){
    }
});

Вземи забранени потребители от коментар

Параметри

Име	Тип	Задължително
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Отговор

Връща: GetBannedUsersFromCommentResponse

Пример

Пример за getBanUsersFromComment

Copy

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

Вземи статус на забрана за коментар

Параметри

Име	Тип	Задължително
tenantId	string	Да
commentId	string	Да
sso	string	Не

Отговор

Връща: GetCommentBanStatusResponse

Пример

getCommentBanStatus Пример

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

Вземи дъщерни коментари

Parameters

Име	Тип	Задължително
tenantId	string	Да
commentId	string	Да
sso	string	Не

Отговор

Връща: ModerationAPIChildCommentsResponse

Пример

Пример за getCommentChildren

Copy

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

Вземи брой

Parameters

Name	Type	Required	Description
tenantId	string	Да
options	const GetCountOptions&	Да

Response

Връща: ModerationAPICountCommentsResponse

Пример

getCount Пример

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

Вземи броеве

Параметри

Име	Тип	Задължителен	Описание
tenantId	string	Yes
sso	string	No

Отговор

Връща: GetBannedUsersCountResponse

Пример

Пример за getCounts

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

Вземи логове

Параметри

Име	Тип	Задължително
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Отговор

Връща: ModerationAPIGetLogsResponse

Пример

Пример за getLogs

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

Вземи ръчни значки

Parameters

Име	Тип	Задължително	Описание
tenantId	string	Да
sso	string	Не

Response

Връща: GetTenantManualBadgesResponse

Example

Пример за getManualBadges

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();
            // обработете отговора, напр., response->badgeList
        } catch (const std::exception& ex) {
            // обработете грешката
        }
    });

Вземи ръчни значки за потребител

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetManualBadgesForUserOptions&	Да

Отговор

Връща: GetUserManualBadgesResponse

Пример

Пример за getManualBadgesForUser

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

Вземи модерационен коментар

Parameters

Име	Тип	Задължително
tenantId	string	Yes
commentId	string	Yes
options	const GetModerationCommentOptions&	Yes

Response

Връща: ModerationAPICommentResponse

Пример

getModerationComment Пример

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-456");
GetModerationCommentOptions options;
options.includeDeleted = boost::optional<bool>(true);
options.locale = boost::optional<utility::string_t>(utility::conversions::to_string_t("en-US"));
api->getModerationComment(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<ModerationAPICommentResponse>> task) {
        try {
            auto response = task.get();
            // Обработете отговора, както е необходимо
        } catch (const std::exception& ex) {
            // Обработете грешката
        }
    });

Вземи текст на модерационен коментар

Параметри

Име	Тип	Required
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Отговор

Връща: GetCommentTextResponse

Пример

Пример за getModerationCommentText

Copy

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

Вземи предварително резюме за забрана

Parameters

Име	Тип	Задължително
tenantId	string	Да
commentId	string	Да
options	const GetPreBanSummaryOptions&	Да

Отговор

Връща: PreBanSummary

Пример

Пример за getPreBanSummary

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();
            // обработи резюме
        } catch (const std::exception&) {
            // обработи грешка
        }
    });

Резюме на търсене за коментари

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetSearchCommentsSummaryOptions&	Да

Отговор

Връща: ModerationCommentSearchResponse

Пример

Пример за getSearchCommentsSummary

Copy

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

Търсене на страници

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetSearchPagesOptions&	Да

Отговор

Връща: ModerationPageSearchResponse

Пример

Пример за 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();
            // използвайте отговора
        } catch (const std::exception& e) {
            // обработете грешката
        }
    });

Търсене на сайтове

Parameters

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

Response

Returns: ModerationSiteSearchResponse

Example

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) {
               // обработка
           }
       } catch (const std::exception&) {
           // обработка на грешки
       }
   });

Предложения за търсене

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetSearchSuggestOptions&	Да

Отговор

Връща: ModerationSuggestResponse

Пример

Пример за getSearchSuggest

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

Търси потребители

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetSearchUsersOptions&	Да

Отговор

Връща: ModerationUserSearchResponse

Пример

getSearchUsers Пример

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

Вземи фактор на доверието

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetTrustFactorOptions&	Да

Отговор

Връща: GetUserTrustFactorResponse

Пример

Пример за getTrustFactor

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

Вземи предпочитания за забрана на потребител

Parameters

Име	Тип	Задължително	Описание
tenantId	string	Да
sso	string	Не

Отговор

Връща: APIModerateGetUserBanPreferencesResponse

Пример

Пример за 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, sno)
    .then([](pplx::task<std::shared_ptr<APIModerateGetUserBanPreferencesResponse>> t) {
        try {
            auto resp = t.get();
        } catch (const std::exception&) {
        }
    });

Вземи вътрешен профил на потребител

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
options	const GetUserInternalProfileOptions&	Yes

Отговор

Връща: GetUserInternalProfileResponse

Пример

Пример getUserInternalProfile

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

Адаптирай гласове за коментари (POST)

Параметри

Име	Тип	Задължително
tenantId	string	Да
commentId	string	Да
adjustCommentVotesParams	AdjustCommentVotesParams	Да
options	const PostAdjustCommentVotesOptions&	Да

Отговор

Връща: AdjustVotesResponse

Пример

postAdjustCommentVotes Пример

Copy

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

Стартирай API експорт (POST)

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
options	const PostApiExportOptions&	Yes

Отговор

Връща: ModerationExportResponse

Пример

postApiExport Пример

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) {
            // обработване на успешен отговор от експорта
        }
    })
    .wait();

Забрани потребител от коментар (POST)

Parameters

Име	Тип	Задължително
tenantId	string	Yes
commentId	string	Yes
options	const PostBanUserFromCommentOptions&	Yes

Response

Връща: BanUserFromCommentResult

Example

postBanUserFromComment Пример

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) {
        // обработка на резултата
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* обработка на грешка */ }
    });

Отмени забрана на потребител (POST)

Параметри

Име	Тип	Задължително
tenantId	string	Yes
banUserUndoParams	BanUserUndoParams	Yes
sso	string	No

Отговор

Връща: APIEmptyResponse

Пример

postBanUserUndo Пример

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){
    // обработи успеха
});

Масово предварително резюме за забрана (POST)

Параметри

Име	Тип	Задължително
tenantId	string	Да
bulkPreBanParams	BulkPreBanParams	Да
options	const PostBulkPreBanSummaryOptions&	Да

Отговор

Връща: BulkPreBanSummary

Пример

postBulkPreBanSummary пример

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

Вземи коментари по ID (POST)

Параметри

Име	Тип	Задължително
tenantId	string	Да
commentsByIdsParams	CommentsByIdsParams	Да
sso	string	Не

Отговор

Връща: ModerationAPIChildCommentsResponse

Пример

postCommentsByIds Пример

Copy

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

Маркирай коментар (POST)

Параметри

Име	Тип	Задължително
tenantId	string	Yes
commentId	string	Yes
options	const PostFlagCommentOptions&	Yes

Отговор

Връща: APIEmptyResponse

Пример

postFlagComment Пример

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

Премахни коментар (POST)

Параметри

Име	Тип	Задължително
tenantId	string	Да
commentId	string	Да
options	const PostRemoveCommentOptions&	Да

Отговор

Връща: PostRemoveCommentApiResponse

Пример

postRemoveComment Пример

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();
            // Обработете отговора
        } catch (const std::exception& ex) {
            // Обработете грешката
        }
    });

Възстанови изтрит коментар (POST)

Parameters

Име	Тип	Задължително
tenantId	string	Yes
commentId	string	Yes
options	const PostRestoreDeletedCommentOptions&	Yes

Response

Връща: APIEmptyResponse

Example

postRestoreDeletedComment Пример

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

Задай статус на одобрение на коментар (POST)

Параметри

Име	Тип	Задължително
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentApprovalStatusOptions&	Yes

Отговор

Връща: SetCommentApprovedResponse

Пример

postSetCommentApprovalStatus Пример

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

Задай статус на преглед на коментар (POST)

Параметри

Име	Тип	Задължително
tenantId	string	Да
commentId	string	Да
options	const PostSetCommentReviewStatusOptions&	Да

Отговор

Връща: APIEmptyResponse

Пример

postSetCommentReviewStatus Пример

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

Задай статус на спам за коментар (POST)

Параметри

Име	Тип	Задължително
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentSpamStatusOptions&	Yes

Отговор

Връща: APIEmptyResponse

Пример

postSetCommentSpamStatus Пример

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

Задай текст на коментар (POST)

Параметри

Име	Тип	Задължително
tenantId	string	Yes
commentId	string	Yes
setCommentTextParams	SetCommentTextParams	Yes
options	const PostSetCommentTextOptions&	Yes

Отговор

Връща: SetCommentTextResponse

Пример

postSetCommentText Пример

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

Премахни маркировка на коментар (POST)

Параметри

Име	Тип	Задължително
tenantId	string	Да
commentId	string	Да
options	const PostUnFlagCommentOptions&	Да

Отговор

Връща: APIEmptyResponse

Пример

postUnFlagComment Пример

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) {
        // обработка може да се извърши тук
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

Подай глас (POST)

Параметри

Име	Тип	Задължително
tenantId	string	Yes
commentId	string	Yes
options	const PostVoteOptions&	Yes

Отговор

Връща: VoteResponse

Пример

postVote Пример

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

Възнагради със значка (PUT)

Parameters

Име	Тип	Задължително
tenantId	string	Yes
badgeId	string	Yes
options	const PutAwardBadgeOptions&	Yes

Response

Връща: AwardUserBadgeResponse

Example

Пример за putAwardBadge

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

Затвори тема (PUT)

Параметри

Име	Тип	Задължително
tenantId	string	Да
urlId	string	Да
sso	string	Не

Отговор

Връща: APIEmptyResponse

Пример

putCloseThread Пример

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

Премахни значка (PUT)

Параметри

Име	Тип	Задължителен
tenantId	string	Да
badgeId	string	Да
options	const PutRemoveBadgeOptions&	Да

Отговор

Връща: RemoveUserBadgeResponse

Пример

putRemoveBadge Пример

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

Преотвори тема (PUT)

Параметри

Име	Тип	Задължително
tenantId	string	Да
urlId	string	Да
sso	string	Не

Отговор

Връща: APIEmptyResponse

Пример

Пример за putReopenThread

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

Задай фактор на доверие

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const SetTrustFactorOptions&	Да

Отговор

Връща: SetUserTrustFactorResponse

Пример

Пример за setTrustFactor

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

Създай модератор

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
createModeratorBody	CreateModeratorBody	Yes

Отговор

Връща: CreateModeratorResponse

Пример

Пример за createModerator

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

Изтрий модератор

Параметри

Име	Тип	Задължително
tenantId	string	Yes
id	string	Yes
sendEmail	string	No

Отговор

Връща: APIEmptyResponse

Пример

Пример за deleteModerator

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) {
        // обработване на успеха
    });

Вземи модератор

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
id	string	Yes

Отговор

Връща: GetModeratorResponse

Пример

Пример за getModerator

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

Вземи модератори

Параметри

Name	Type	Required	Description
tenantId	string	Yes
skip	double	No

Отговор

Връща: GetModeratorsResponse

Пример

getModerators Пример

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

Изпрати покана

Parameters

Име	Тип	Задължително
tenantId	string	Yes
id	string	Yes
fromName	string	Yes

Response

Връща: APIEmptyResponse

Example

Пример за sendInvite

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) {
    // обработи успешно поканата
});

Обнови модератор

Параметри

Име	Тип	Задължително
tenantId	string	Yes
id	string	Yes
updateModeratorBody	UpdateModeratorBody	Yes

Отговор

Връща: APIEmptyResponse

Пример

updateModerator Пример

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

Изтрий брой на уведомленията

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
id	string	Да

Отговор

Връща: APIEmptyResponse

Пример

Пример deleteNotificationCount

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

Вземи кеширан брой известия

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
id	string	Да

Отговор

Returns: GetCachedNotificationCountResponse

Пример

Пример за getCachedNotificationCount

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();
            // process response
        } catch (const std::exception&) {
            // handle error
        }
    });

Вземи брой известия

Параметри

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

Отговор

Връща: GetNotificationCountResponse

Пример

Пример за getNotificationCount

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

Вземи известия

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetNotificationsOptions&	Да

Отговор

Връща: GetNotificationsResponse

Пример

getNotifications Пример

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

Обнови известие

Параметри

Име	Тип	Задължително
tenantId	string	Да
id	string	Да
updateNotificationBody	UpdateNotificationBody	Да
userId	string	Не

Отговор

Връща: APIEmptyResponse

Пример

updateNotification Пример

Copy

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

Създай реакция на страница V1

Параметри

Име	Тип	Задължително
tenantId	string	Yes
urlId	string	Yes
title	string	No

Отговор

Връща: CreateV1PageReact

Пример

createV1PageReact Пример

Copy

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

Създай реакция на страница V2

Параметри

Име	Тип	Задължително
tenantId	string	Yes
urlId	string	Yes
id	string	Yes
title	string	No

Отговор

Връща: CreateV1PageReact

Пример

Пример за createV2PageReact

Copy

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

Изтрий реакция на страница V1

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
urlId	string	Да

Отговор

Връща: CreateV1PageReact

Пример

deleteV1PageReact Пример

Copy

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

Изтрий реакция на страница V2

Параметри

Име	Тип	Задължително
tenantId	string	Да
urlId	string	Да
id	string	Да

Отговор

Връща: CreateV1PageReact

Пример

Пример за deleteV2PageReact

Copy

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

Вземи харесвания на страница V1

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
urlId	string	Yes

Отговор

Връща: GetV1PageLikes

Пример

getV1PageLikes Пример

Copy

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

Вземи реакции на страница V2

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
urlId	string	Да

Отговор

Връща: GetV2PageReacts

Пример

Пример за 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 (...) {}
    });

Вземи потребители, които реагираха на страница V2

Параметри

Name	Type	Required
tenantId	string	Да
urlId	string	Да
id	string	Да

Отговор

Връща: GetV2PageReactUsersResponse

Пример

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();
        // Използвайте отговора при нужда
    }catch(const std::exception&){
        // Обработете грешка
    }
});

Добави страница

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
createAPIPageData	CreateAPIPageData	Да

Отговор

Връща: AddPageAPIResponse

Пример

addPage Пример

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) {
            // обработка на успешно добавяне
        } else {
            // обработка на грешка
        }
    });

Изтрий страница

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
id	string	Да

Отговор

Връща: DeletePageAPIResponse

Пример

deletePage Пример

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();
           // обработете отговора, както е необходимо
       } catch (const std::exception& ex) {
           // обработете грешката
       }
   });

Вземи офлайн потребители

Past коментатори на страницата, които НЕ са онлайн в момента. Подредени по displayName.
Използвайте това след изчерпване на /users/online, за да рендерирате раздел „Members“.
Курсорно пагиниране по commenterName: сървърът обхожда частичния {tenantId, urlId, commenterName}
индекс от afterName напред чрез $gt, без разход за $skip.

Parameters

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

Response

Връща: PageUsersOfflineResponse

Пример

Пример за getOfflineUsers

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

Вземи онлайн потребители

Текущо онлайн зрители на страница: хора, чиято уебсокет сесия е абонирана за страницата в момента.
Връща anonCount + totalCount (абонати в цялата стая, включително анонимни зрители, които не изброяваме).

Parameters

Име	Тип	Задължително
tenantId	string	Да
urlId	string	Да
options	const GetOnlineUsersOptions&	Да

Response

Връща: PageUsersOnlineResponse

Пример

Пример за 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&){
    }
});

Вземи страница по URL ID

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
urlId	string	Да

Отговор

Връща: GetPageByURLIdAPIResponse

Пример

Пример за getPageByURLId

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

Вземи страници

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes

Отговор

Връща: GetPagesAPIResponse

Пример

getPages Пример

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

Вземи страници (публично)

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

Parameters

Име	Тип	Задължително	Описание
tenantId	string	Yes
options	const GetPagesPublicOptions&	Yes

Response

Връща: GetPublicPagesResponse

Example

getPagesPublic Пример

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();
        // обработете отговора, ако е необходимо
    }catch(const std::exception&){
        // обработете грешката, ако е необходимо
    }
});

Вземи информация за потребители

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

Parameters

Name	Type	Required	Description
tenantId	string	Yes
ids	string	Yes

Response

Returns: PageUsersInfoResponse

Example

Пример за getUsersInfo

Copy

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

Частично обнови страница

Параметри

Име	Тип	Задължително
tenantId	string	Да
id	string	Да
updateAPIPageData	UpdateAPIPageData	Да

Отговор

Връща: PatchPageAPIResponse

Пример

patchPage Пример

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) {
            // обработи успеха
        }
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

Изтрий чакащо уебхук събитие

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
id	string	Yes

Отговор

Връща: APIEmptyResponse

Пример

deletePendingWebhookEvent Пример

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

Вземи брой чакащи уебхук събития

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
options	const GetPendingWebhookEventCountOptions&	Yes

Отговор

Връща: GetPendingWebhookEventCountResponse

Пример

Пример за getPendingWebhookEventCount

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

Вземи чакащи уебхук събития

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetPendingWebhookEventsOptions&	Да

Отговор

Връща: GetPendingWebhookEventsResponse

Пример

getPendingWebhookEvents Пример

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

Създай конфигурация на въпрос

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
createQuestionConfigBody	CreateQuestionConfigBody	Yes

Отговор

Връща: CreateQuestionConfigResponse

Пример

Пример за createQuestionConfig

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

Изтрий конфигурация на въпрос

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
id	string	Yes

Отговор

Връща: APIEmptyResponse

Пример

deleteQuestionConfig Пример

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) {
        // обработка на успешно изтриване
    })
    .then([](pplx::task<void> t) {
        try {
            t.get();
        } catch (const std::exception&) {
            // обработка на грешка
        }
    });

Вземи конфигурация на въпрос

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
id	string	Yes

Отговор

Връща: GetQuestionConfigResponse

Пример

getQuestionConfig Пример

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();
            // Използвайте отговора, както е необходимо
        } catch (const std::exception&) {
            // Обработете грешката
        }
    });

Вземи конфигурации на въпроси

Parameters

Name	Type	Required	Description
tenantId	string	Yes
skip	double	No

Response

Връща: GetQuestionConfigsResponse

Example

Пример за getQuestionConfigs

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

Обнови конфигурация на въпрос

Параметри

Име	Тип	Задължително
tenantId	string	Yes
id	string	Yes
updateQuestionConfigBody	UpdateQuestionConfigBody	Yes

Отговор

Връща: APIEmptyResponse

Пример

updateQuestionConfig Пример

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

Създай резултат от въпрос

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
createQuestionResultBody	CreateQuestionResultBody	Yes

Отговор

Връща: CreateQuestionResultResponse

Пример

Пример за createQuestionResult

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

Изтрий резултат от въпрос

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
id	string	Yes

Отговор

Връща: APIEmptyResponse

Пример

Пример за deleteQuestionResult

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();
                // обработка на успеха
            }
            catch ( const std::exception& e )
            {
                // обработка на грешки
            }
        } );
}

Вземи резултат от въпрос

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
id	string	Да

Отговор

Връща: GetQuestionResultResponse

Пример

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

Вземи резултати от въпроси

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
options	const GetQuestionResultsOptions&	Yes

Отговор

Връща: GetQuestionResultsResponse

Пример

Пример за getQuestionResults

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();
        // обработка на отговора
    });

Обнови резултат от въпрос

Параметри

Име	Тип	Задължително
tenantId	string	Да
id	string	Да
updateQuestionResultBody	UpdateQuestionResultBody	Да

Отговор

Връща: APIEmptyResponse

Пример

updateQuestionResult Пример

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

Агрегирай резултати от въпроси

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const AggregateQuestionResultsOptions&	Да

Отговор

Връща: AggregateQuestionResultsResponse

Пример

aggregateQuestionResults Пример

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

Масово агрегиране на резултати от въпроси

Параметри

Име	Тип	Задължително
tenantId	string	Yes
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Yes
forceRecalculate	bool	No

Отговор

Връща: BulkAggregateQuestionResultsResponse

Пример

bulkAggregateQuestionResults Пример

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

Съчетай коментари с резултати от въпроси

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const CombineCommentsWithQuestionResultsOptions&	Да

Отговор

Връща: CombineQuestionResultsWithCommentsResponse

Пример

combineCommentsWithQuestionResults Пример

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);
            // Използвайте комбинираното, както е необходимо
        }catch(const std::exception&){
        }
    });

Добави SSO потребител

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
createAPISSOUserData	CreateAPISSOUserData	Да

Отговор

Връща: AddSSOUserAPIResponse

Пример

addSSOUser Пример

Copy

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

Изтрий SSO потребител

Параметри

Име	Тип	Задължително
tenantId	string	Да
id	string	Да
options	const DeleteSSOUserOptions&	Да

Отговор

Връща: DeleteSSOUserAPIResponse

Пример

Пример за deleteSSOUser

Copy

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

Вземи SSO потребител по имейл

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
email	string	Да

Отговор

Връща: GetSSOUserByEmailAPIResponse

Пример

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

Вземи SSO потребител по ID

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
id	string	Да

Отговор

Връща: GetSSOUserByIdAPIResponse

Пример

Пример за getSSOUserById

Copy

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

Вземи SSO потребители

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
skip	int32_t	Не

Отговор

Връща: GetSSOUsersResponse

Пример

Пример getSSOUsers

Copy

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

Частично обнови SSO потребител

Параметри

Име	Тип	Задължително
tenantId	string	Yes
id	string	Yes
updateAPISSOUserData	UpdateAPISSOUserData	Yes
updateComments	bool	No

Отговор

Връща: PatchSSOUserAPIResponse

Пример

Пример за patchSSOUser

Copy

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

Задай SSO потребител (PUT)

Параметри

Име	Тип	Задължително
tenantId	string	Yes
id	string	Yes
updateAPISSOUserData	UpdateAPISSOUserData	Yes
updateComments	bool	No

Отговор

Връща: PutSSOUserAPIResponse

Пример

putSSOUser Пример

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

Създай абонамент

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Да

Отговор

Връща: CreateSubscriptionAPIResponse

Пример

createSubscription Пример

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

Изтрий абонамент

Параметри

Име	Тип	Задължително
tenantId	string	Да
id	string	Да
userId	string	Не

Отговор

Връща: DeleteSubscriptionAPIResponse

Пример

deleteSubscription Пример

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

Вземи абонаменти

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
userId	string	Не

Отговор

Връща: GetSubscriptionsAPIResponse

Пример

Пример за getSubscriptions

Copy

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

Обнови абонамент

Параметри

Име	Тип	Изисква се
tenantId	string	Yes
id	string	Yes
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	Yes
userId	string	No

Отговор

Returns: UpdateSubscriptionAPIResponse

Пример

Пример за updateSubscription

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

Вземи дневна употреба на наемател

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetTenantDailyUsagesOptions&	Да

Отговор

Връща: GetTenantDailyUsagesResponse

Пример

Пример за 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();

Създай пакет за наемател

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
createTenantPackageBody	CreateTenantPackageBody	Да

Отговор

Връща: CreateTenantPackageResponse

Пример

Пример за createTenantPackage

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

Изтрий пакет за наемател

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
id	string	Да

Отговор

Връща: APIEmptyResponse

Пример

Пример за deleteTenantPackage

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

Вземи пакет за наемател

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
id	string	Да

Отговор

Връща: GetTenantPackageResponse

Пример

getTenantPackage Пример

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

Вземи пакети за наемател

Параметри

Name	Type	Required	Description
tenantId	string	Yes
skip	double	No

Отговор

Връща: GetTenantPackagesResponse

Пример

Пример getTenantPackages

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

Замени пакет за наемател

Параметри

Name	Type	Required
tenantId	string	Yes
id	string	Yes
replaceTenantPackageBody	ReplaceTenantPackageBody	Yes

Отговор

Връща: APIEmptyResponse

Пример

replaceTenantPackage Пример

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

Обнови пакет за наемател

Parameters

Име	Тип	Задължително
tenantId	string	Yes
id	string	Yes
updateTenantPackageBody	UpdateTenantPackageBody	Yes

Response

Връща: APIEmptyResponse

Example

updateTenantPackage Пример

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();
            // обработка при успех
        } catch (const std::exception& ex) {
            // обработка при грешка
        }
    });

Създай потребител на наемателя

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
createTenantUserBody	CreateTenantUserBody	Да

Отговор

Връща: CreateTenantUserResponse

Пример

createTenantUser Пример

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

Изтрий потребител на наемателя

Параметри

Име	Тип	Задължително
tenantId	string	Да
id	string	Да
options	const DeleteTenantUserOptions&	Да

Отговор

Връща: APIEmptyResponse

Пример

deleteTenantUser Пример

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

Вземи потребител на наемателя

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
id	string	Да

Отговор

Връща: GetTenantUserResponse

Пример

Пример за getTenantUser

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();
            // Използвайте отговора по желание
        } catch (const std::exception&) {
            // Обработка на грешки
        }
    });

Вземи потребители на наемателя

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
skip	double	Не

Отговор

Връща: GetTenantUsersResponse

Пример

Пример за getTenantUsers

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

Замени потребител на наемателя

Параметри

Име	Тип	Задължително
tenantId	string	Yes
id	string	Yes
replaceTenantUserBody	ReplaceTenantUserBody	Yes
updateComments	string	No

Отговор

Връща: APIEmptyResponse

Пример

replaceTenantUser Пример

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

Изпрати линк за влизане

Параметри

Име	Тип	Задължително
tenantId	string	Yes
id	string	Yes
redirectURL	string	No

Отговор

Връща: APIEmptyResponse

Пример

sendLoginLink Пример

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

Обнови потребител на наемателя

Параметри

Име	Тип	Задължително
tenantId	string	Да
id	string	Да
updateTenantUserBody	UpdateTenantUserBody	Да
updateComments	string	Не

Отговор

Връща: APIEmptyResponse

Пример

Пример за updateTenantUser

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

Създай наемател

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
createTenantBody	CreateTenantBody	Да

Отговор

Връща: CreateTenantResponse

Пример

createTenant Пример

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

Изтрий наемател

Параметри

Име	Тип	Задължително
tenantId	string	Да
id	string	Да
sure	string	Не

Отговор

Връща: APIEmptyResponse

Пример

Пример за deleteTenant

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

Вземи наемател

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
id	string	Да

Отговор

Връща: GetTenantResponse

Пример

Пример за getTenant

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

Вземи наематели

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetTenantsOptions&	Да

Отговор

Връща: GetTenantsResponse

Пример

Пример getTenants

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

Обнови наемател

Параметри

Име	Тип	Задължително
tenantId	string	Yes
id	string	Yes
updateTenantBody	UpdateTenantBody	Yes

Отговор

Връща: APIEmptyResponse

Пример

updateTenant Пример

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

Промени състоянието на билет

Параметри

Име	Тип	Задължително
tenantId	string	Yes
userId	string	Yes
id	string	Yes
changeTicketStateBody	ChangeTicketStateBody	Yes

Отговор

Връща: ChangeTicketStateResponse

Пример

changeTicketState Пример

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

Създай билет

Parameters

Name	Type	Required
tenantId	string	Yes
userId	string	Yes
createTicketBody	CreateTicketBody	Yes

Response

Връща: CreateTicketResponse

Example

Пример за createTicket

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();
        // Използвайте отговора според нужда
    }catch(const std::exception&){
        // Обработете грешката
    }
});

Вземи билет

Параметри

Име	Тип	Задължително
tenantId	string	Да
id	string	Да
userId	string	Не

Отговор

Връща: GetTicketResponse

Пример

Пример getTicket

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

Вземи билети

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
options	const GetTicketsOptions&	Yes

Отговор

Returns: GetTicketsResponse

Пример

Пример за getTickets

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

Вземи преводи

Параметри

Име	Тип	Задължително
r_namespace	string	Да
component	string	Да
options	const GetTranslationsOptions&	Да

Отговор

Връща: GetTranslationsResponse

Пример

Пример за getTranslations

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

Качи изображение

Upload and resize an image

Качване и преоразмеряване на изображение

Parameters

Параметри

Name	Type	Required
tenantId	string	Yes
file	HttpContent	Yes
options	const UploadImageOptions&	Yes

Име	Тип	Задължително
tenantId	string	Да
file	HttpContent	Да
options	const UploadImageOptions&	Да

Response

Отговор

Returns: UploadImageResponse Връща: UploadImageResponse

Example

Пример

Пример за uploadImage

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

Вземи напредъка на значка за потребител по ID

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
id	string	Да

Отговор

Връща: APIGetUserBadgeProgressResponse

Пример

Пример за getUserBadgeProgressById

Copy

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

Вземи напредъка на значка за потребител по потребителско ID

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
userId	string	Yes

Отговор

Връща: APIGetUserBadgeProgressResponse

Пример

Пример за getUserBadgeProgressByUserId

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

Вземи списък с напредъка на значки на потребител

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetUserBadgeProgressListOptions&	Да

Отговор

Връща: APIGetUserBadgeProgressListResponse

Пример

Пример за getUserBadgeProgressList

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) {
            // обработи значка
        }
    });

Създай значка за потребител

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
createUserBadgeParams	CreateUserBadgeParams	Да

Отговор

Връща: APICreateUserBadgeResponse

Пример

createUserBadge Пример

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

Изтрий значка за потребител

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
id	string	Да

Отговор

Връща: APIEmptySuccessResponse

Пример

Пример за deleteUserBadge

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

Вземи значка за потребител

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
id	string	Да

Отговор

Връща: APIGetUserBadgeResponse

Пример

getUserBadge Пример

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

Вземи значки за потребител

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetUserBadgesOptions&	Да

Отговор

Връща: APIGetUserBadgesResponse

Пример

Пример за getUserBadges

Copy

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

Обнови значка за потребител

Параметри

Име	Тип	Задължителен
tenantId	string	Да
id	string	Да
updateUserBadgeParams	UpdateUserBadgeParams	Да

Отговор

Връща: APIEmptySuccessResponse

Пример

Пример за updateUserBadge

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

Вземи брой потребителски известия

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
sso	string	Не

Отговор

Връща: GetUserNotificationCountResponse

Пример

Пример за 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();
        // използвайте resp според нуждите
    }catch(const std::exception&){
        // обработете грешката
    }
});

Вземи потребителски известия

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const GetUserNotificationsOptions&	Да

Отговор

Връща: GetMyNotificationsResponse

Пример

getUserNotifications Пример

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

Нулирай брой потребителски известия

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Yes
sso	string	No

Отговор

Връща: ResetUserNotificationsResponse

Пример

Пример за resetUserNotificationCount

Copy

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

Нулирай потребителски известия

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
options	const ResetUserNotificationsOptions&	Да

Отговор

Връща: ResetUserNotificationsResponse

Пример

resetUserNotifications Пример

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) {
        // Обработете отговора
    });

Обнови статус на абонамент за известия за коментари на потребителя

Enable or disable notifications for a specific comment.

Parameters

Име	Тип	Задължително
tenantId	string	Yes
notificationId	string	Yes
optedInOrOut	string	Yes
commentId	string	Yes
sso	string	No

Response

Връща: UpdateUserNotificationCommentSubscriptionStatusResponse

Example

Пример за 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;
});

Обнови статус на абонамент за известия за страници на потребителя

Enable or disable notifications for a page. When users are subscribed to a page, notifications are created for new root comments, and also

Parameters

Име	Тип	Задължително
tenantId	string	Yes
urlId	string	Yes
url	string	Yes
pageTitle	string	Yes
subscribedOrUnsubscribed	string	Yes
sso	string	No

Отговор

Връща: UpdateUserNotificationPageSubscriptionStatusResponse

Пример

Пример за updateUserNotificationPageSubscriptionStatus

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) {
        // обработете resp, ако е необходимо
    });

Обнови статус на потребителски известия

Параметри

Име	Тип	Задължително
tenantId	string	Да
notificationId	string	Да
newStatus	string	Да
sso	string	Не

Отговор

Връща: UpdateUserNotificationStatusResponse

Пример

updateUserNotificationStatus Пример

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

Вземи статуси на присъствие на потребителя

Параметри

Име	Тип	Задължително
tenantId	string	Да
urlIdWS	string	Да
userIds	string	Да

Отговор

Връща: GetUserPresenceStatusesResponse

Пример

Пример за getUserPresenceStatuses

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

Търси потребители

Параметри

Име	Тип	Задължително
tenantId	string	Yes
urlId	string	Yes
options	const SearchUsersOptions&	Yes

Отговор

Връща: SearchUsersResult

Пример

searchUsers Пример

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

Вземи потребител

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
id	string	Да

Отговор

Връща: GetUserResponse

Пример

getUser Пример

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>();
            }
            // обработете отговора според нуждите
        } catch (const std::exception&) {
            // обработете грешката
        }
    });

Създай глас

Параметри

Име	Тип	Задължително
tenantId	string	Да
commentId	string	Да
direction	string	Да
options	const CreateVoteOptions&	Да

Отговор

Връща: VoteResponse

Пример

createVote Пример

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

Изтрий глас

Параметри

Име	Тип	Задължително
tenantId	string	Да
id	string	Да
editKey	string	Не

Отговор

Връща: VoteDeleteResponse

Пример

deleteVote Пример

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();
        // Обработете отговора по необходимост
    } catch (const std::exception&) {
        // Обработете грешката
    }
});

Вземи гласове

Параметри

Име	Тип	Задължително	Описание
tenantId	string	Да
urlId	string	Да

Отговор

Връща: GetVotesResponse

Пример

getVotes Пример

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 (...) {
        // обработка на грешки
    }
});

Вземи гласове за потребител

Параметри

Име	Тип	Задължително
tenantId	string	Да
urlId	string	Да
options	const GetVotesForUserOptions&	Да

Отговор

Връща: GetVotesForUserResponse

Пример

Пример getVotesForUser

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) {
        // обработи отговора, напр., обхождай гласовете
    }
});

Нуждаете ли се от помощ?

Ако срещнете проблеми или имате въпроси относно C++ SDK, моля:

Принос

Приноси са добре дошли! Моля, посетете репозитория в GitHub за указания относно приносянето.

Език 🇧🇬 Български

Документация

Първи стъпки

Референция на API

Използване

Агрегиране

Одитни записи

Удостоверяване

Блокиране от коментар

Проверка за блокирани коментари

Коментари

Коментари за потребителя

Конфигурации на домейни

Шаблони за имейли

Регистър на събития

Публикации във фийда

Маркиране на коментар

GIF-ове

Хаштагове

Модерация

Модератори

Брой известия

Известия

Реакции на страница

Страници

Чакащи уебхук събития

Конфигурации на въпроси

Резултати от въпроси

Агрегиране на резултати от въпроси

SSO потребители

Абонаменти

Дневна употреба на наемател

Пакети на наемателя

Потребители на наемателя

Наематели

Билети

Преводи

Качване на изображение

Напредък на значки на потребител

Значки на потребител

Потребителски известия

Статуси на присъствие на потребител

Търсене на потребители

Потребители

Гласове

FastComments C++ SDK

Репозитория

Изисквания

Инсталиране

Install Dependencies

Building from Source

Installing

Library Contents

Public vs Secured APIs

Бърз старт

Using Authenticated APIs (DefaultAPI)

Using Public APIs (PublicAPI)

Using Moderation APIs (ModerationApi)

Common Issues

Извикване на API: Синхронно срещу Асинхронно

Synchronous Calls with .get()

Asynchronous Calls with .then()

Choosing Between Synchronous and Asynchronous

Забележки

Идентификатори на излъчване

SSO (Единно влизане)

Използване на SSO

Просто SSO

Сигурно SSO

Документация за fastcomments

Документация за API крайни точки

Документация за модели

Агрегиране

Параметри

Отговор

Пример

Вземи одитни записи

Parameters

Response

Example

Synchronous Calls with `.get()`

Asynchronous Calls with `.then()`