SDK C++ do FastComments

Isto é o SDK oficial em C++ para o FastComments.

SDK oficial em C++ para a API do FastComments

Repositório

Requisitos

C++17 ou posterior
CMake 3.14 ou posterior
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (baixado automaticamente para testes)

Instalação

Instalar Dependências

sudo apt install libcpprest-dev libboost-all-dev

Compilando a partir do Código-Fonte

mkdir build
cd build
cmake ..
make

Instalando

sudo make install

Conteúdo da Biblioteca

Esta biblioteca contém o cliente de API gerado e as utilidades SSO para facilitar o trabalho com a API.

API Client Library Docs

APIs Públicas vs Seguras

Para o cliente de API, há três classes, DefaultApi, PublicApi e ModerationApi. O DefaultApi contém métodos que exigem sua chave de API, e o PublicApi contém métodos que podem ser chamados diretamente de um navegador/dispositivo móvel/etc sem autenticação. O ModerationApi fornece um conjunto extenso de APIs de moderação em tempo real e rápidas. Cada método do ModerationApi aceita um parâmetro sso e pode autenticar via SSO ou um cookie de sessão do FastComments.com.

Início Rápido

Usando APIs Autenticadas (DefaultAPI)

Importante:

Você deve definir a URL base (o gerador cpp‑restsdk não a lê da especificação OpenAPI)
Você deve definir sua chave de API no ApiClient antes de fazer solicitações autenticadas. Caso não o faça, as solicitações falharão com erro 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;
}

Usando APIs Públicas (PublicAPI)

Endpoints públicos não requerem autenticação:

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

Usando APIs de Moderação (ModerationApi)

O ModerationApi alimenta o painel de moderador. Cada método aceita um parâmetro sso para que a chamada seja executada em nome de um moderador autenticado via SSO (veja a seção SSO abaixo para como criar um 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;
}

Problemas Comuns

Erro "URI must contain a hostname": Certifique‑se de chamar config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) antes de criar o ApiClient. O gerador cpp‑restsdk não lê automaticamente a URL do servidor da especificação OpenAPI.
Erro 401 "missing‑api‑key": Certifique‑se de chamar config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) antes de criar a instância DefaultAPI.
Classe de API incorreta: Use DefaultApi para solicitações autenticadas do lado do servidor, PublicApi para solicitações cliente/públicas e ModerationApi para solicitações do painel de moderador (autenticadas com um token SSO de moderador).

Fazendo chamadas de API: Síncronas vs Assíncronas

Todos os métodos de API neste SDK retornam pplx::task<std::shared_ptr<ResponseType>> da C++ REST SDK. Isso lhe oferece flexibilidade na forma como você trata as respostas da API.

Chamadas síncronas com `.get()`

Use .get() para bloquear a thread chamadora até que a requisição seja concluída e obter o resultado de forma síncrona:

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

Chamadas assíncronas com `.then()`

Use .then() para execução assíncrona não bloqueante com 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;

Escolhendo entre síncrono e assíncrono

A escolha depende do seu ambiente de execução e da arquitetura da aplicação:

.get() (Bloqueio síncrono)

Bloqueia a thread chamadora até que a requisição HTTP seja concluída
Fluxo de código mais simples, mais fácil de compreender
Adequado para threads de trabalho dedicadas, processamento em lote ou ferramentas de linha de comando
Não adequado para loops de eventos, threads de GUI ou servidores de thread única

.then() (Assíncrono não bloqueante)

Retorna imediatamente, o callback é executado quando a requisição é concluída
Não bloqueia a thread chamadora
Necessário para arquiteturas orientadas a eventos, aplicações GUI ou loops de eventos de thread única
Permite encadear múltiplas operações
Fluxo de controle mais complexo

A suíte de testes do SDK usa .get() exclusivamente, mas isso é apropriado para o ambiente de teste, onde o bloqueio é aceitável.

Notas

IDs de Broadcast

Você verá que deve passar um broadcastId em algumas chamadas de API. Quando você receber eventos, receberá esse ID de volta, então saberá ignorar o evento se planejar aplicar alterações otimisticamente no cliente (o que você provavelmente vai querer fazer, já que oferece a melhor experiência). Passe um UUID aqui. O ID deve ser único o suficiente para não ocorrer duas vezes em uma sessão do navegador.

Para exemplos de SSO, veja abaixo.

Uso de SSO

SSO Simples

#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 Seguro

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

Documentação do fastcomments

Documentação para Endpoints da API

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

Classe	Método	Requisição HTTP	Descrição
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	Agrega documentos agrupando-os (se groupBy for fornecido) e aplicando múltiplas operações. Diferentes operações (por exemplo, soma, contagemDistinta, média, etc.) são suportadas.
DefaultApi	aggregateQuestionResults	GET /api/v1/question-results-aggregation
DefaultApi	blockUserFromComment	POST /api/v1/comments/{id}/block
DefaultApi	bulkAggregateQuestionResults	POST /api/v1/question-results-aggregation/bulk
DefaultApi	changeTicketState	PATCH /api/v1/tickets/{id}/state
DefaultApi	combineCommentsWithQuestionResults	GET /api/v1/question-results-aggregation/combine/comments
DefaultApi	createEmailTemplate	POST /api/v1/email-templates
DefaultApi	createFeedPost	POST /api/v1/feed-posts
DefaultApi	createModerator	POST /api/v1/moderators
DefaultApi	createQuestionConfig	POST /api/v1/question-configs
DefaultApi	createQuestionResult	POST /api/v1/question-results
DefaultApi	createSubscription	POST /api/v1/subscriptions
DefaultApi	createTenant	POST /api/v1/tenants
DefaultApi	createTenantPackage	POST /api/v1/tenant-packages
DefaultApi	createTenantUser	POST /api/v1/tenant-users
DefaultApi	createTicket	POST /api/v1/tickets
DefaultApi	createUserBadge	POST /api/v1/user-badges
DefaultApi	createVote	POST /api/v1/votes
DefaultApi	deleteComment	DELETE /api/v1/comments/{id}
DefaultApi	deleteDomainConfig	DELETE /api/v1/domain-configs/{domain}
DefaultApi	deleteEmailTemplate	DELETE /api/v1/email-templates/{id}
DefaultApi	deleteEmailTemplateRenderError	DELETE /api/v1/email-templates/{id}/render-errors/{errorId}
DefaultApi	deleteHashTag	DELETE /api/v1/hash-tags/{tag}
DefaultApi	deleteModerator	DELETE /api/v1/moderators/{id}
DefaultApi	deleteNotificationCount	DELETE /api/v1/notification-count/{id}
DefaultApi	deletePage	DELETE /api/v1/pages/{id}
DefaultApi	deletePendingWebhookEvent	DELETE /api/v1/pending-webhook-events/{id}
DefaultApi	deleteQuestionConfig	DELETE /api/v1/question-configs/{id}
DefaultApi	deleteQuestionResult	DELETE /api/v1/question-results/{id}
DefaultApi	deleteSSOUser	DELETE /api/v1/sso-users/{id}
DefaultApi	deleteSubscription	DELETE /api/v1/subscriptions/{id}
DefaultApi	deleteTenant	DELETE /api/v1/tenants/{id}
DefaultApi	deleteTenantPackage	DELETE /api/v1/tenant-packages/{id}
DefaultApi	deleteTenantUser	DELETE /api/v1/tenant-users/{id}
DefaultApi	deleteUserBadge	DELETE /api/v1/user-badges/{id}
DefaultApi	deleteVote	DELETE /api/v1/votes/{id}
DefaultApi	flagComment	POST /api/v1/comments/{id}/flag
DefaultApi	getAuditLogs	GET /api/v1/audit-logs
DefaultApi	getCachedNotificationCount	GET /api/v1/notification-count/{id}
DefaultApi	getComment	GET /api/v1/comments/{id}
DefaultApi	getComments	GET /api/v1/comments
DefaultApi	getDomainConfig	GET /api/v1/domain-configs/{domain}
DefaultApi	getDomainConfigs	GET /api/v1/domain-configs
DefaultApi	getEmailTemplate	GET /api/v1/email-templates/{id}
DefaultApi	getEmailTemplateDefinitions	GET /api/v1/email-templates/definitions
DefaultApi	getEmailTemplateRenderErrors	GET /api/v1/email-templates/{id}/render-errors
DefaultApi	getEmailTemplates	GET /api/v1/email-templates
DefaultApi	getFeedPosts	GET /api/v1/feed-posts	req tenantId afterId
DefaultApi	getHashTags	GET /api/v1/hash-tags
DefaultApi	getModerator	GET /api/v1/moderators/{id}
DefaultApi	getModerators	GET /api/v1/moderators
DefaultApi	getNotificationCount	GET /api/v1/notifications/count
DefaultApi	getNotifications	GET /api/v1/notifications
DefaultApi	getPageByURLId	GET /api/v1/pages/by-url-id
DefaultApi	getPages	GET /api/v1/pages
DefaultApi	getPendingWebhookEventCount	GET /api/v1/pending-webhook-events/count
DefaultApi	getPendingWebhookEvents	GET /api/v1/pending-webhook-events
DefaultApi	getQuestionConfig	GET /api/v1/question-configs/{id}
DefaultApi	getQuestionConfigs	GET /api/v1/question-configs
DefaultApi	getQuestionResult	GET /api/v1/question-results/{id}
DefaultApi	getQuestionResults	GET /api/v1/question-results
DefaultApi	getSSOUserByEmail	GET /api/v1/sso-users/by-email/{email}
DefaultApi	getSSOUserById	GET /api/v1/sso-users/by-id/{id}
DefaultApi	getSSOUsers	GET /api/v1/sso-users
DefaultApi	getSubscriptions	GET /api/v1/subscriptions
DefaultApi	getTenant	GET /api/v1/tenants/{id}
DefaultApi	getTenantDailyUsages	GET /api/v1/tenant-daily-usage
DefaultApi	getTenantPackage	GET /api/v1/tenant-packages/{id}
DefaultApi	getTenantPackages	GET /api/v1/tenant-packages
DefaultApi	getTenantUser	GET /api/v1/tenant-users/{id}
DefaultApi	getTenantUsers	GET /api/v1/tenant-users
DefaultApi	getTenants	GET /api/v1/tenants
DefaultApi	getTicket	GET /api/v1/tickets/{id}
DefaultApi	getTickets	GET /api/v1/tickets
DefaultApi	getUser	GET /api/v1/users/{id}
DefaultApi	getUserBadge	GET /api/v1/user-badges/{id}
DefaultApi	getUserBadgeProgressById	GET /api/v1/user-badge-progress/{id}
DefaultApi	getUserBadgeProgressByUserId	GET /api/v1/user-badge-progress/user/{userId}
DefaultApi	getUserBadgeProgressList	GET /api/v1/user-badge-progress
DefaultApi	getUserBadges	GET /api/v1/user-badges
DefaultApi	getVotes	GET /api/v1/votes
DefaultApi	getVotesForUser	GET /api/v1/votes/for-user
DefaultApi	patchDomainConfig	PATCH /api/v1/domain-configs/{domainToUpdate}
DefaultApi	patchHashTag	PATCH /api/v1/hash-tags/{tag}
DefaultApi	patchPage	PATCH /api/v1/pages/{id}
DefaultApi	patchSSOUser	PATCH /api/v1/sso-users/{id}
DefaultApi	putDomainConfig	PUT /api/v1/domain-configs/{domainToUpdate}
DefaultApi	putSSOUser	PUT /api/v1/sso-users/{id}
DefaultApi	renderEmailTemplate	POST /api/v1/email-templates/render
DefaultApi	replaceTenantPackage	PUT /api/v1/tenant-packages/{id}
DefaultApi	replaceTenantUser	PUT /api/v1/tenant-users/{id}
DefaultApi	saveComment	POST /api/v1/comments
DefaultApi	saveCommentsBulk	POST /api/v1/comments/bulk
DefaultApi	sendInvite	POST /api/v1/moderators/{id}/send-invite
DefaultApi	sendLoginLink	POST /api/v1/tenant-users/{id}/send-login-link
DefaultApi	unBlockUserFromComment	POST /api/v1/comments/{id}/un-block
DefaultApi	unFlagComment	POST /api/v1/comments/{id}/un-flag
DefaultApi	updateComment	PATCH /api/v1/comments/{id}
DefaultApi	updateEmailTemplate	PATCH /api/v1/email-templates/{id}
DefaultApi	updateFeedPost	PATCH /api/v1/feed-posts/{id}
DefaultApi	updateModerator	PATCH /api/v1/moderators/{id}
DefaultApi	updateNotification	PATCH /api/v1/notifications/{id}
DefaultApi	updateQuestionConfig	PATCH /api/v1/question-configs/{id}
DefaultApi	updateQuestionResult	PATCH /api/v1/question-results/{id}
DefaultApi	updateSubscription	PATCH /api/v1/subscriptions/{id}
DefaultApi	updateTenant	PATCH /api/v1/tenants/{id}
DefaultApi	updateTenantPackage	PATCH /api/v1/tenant-packages/{id}
DefaultApi	updateTenantUser	PATCH /api/v1/tenant-users/{id}
DefaultApi	updateUserBadge	PUT /api/v1/user-badges/{id}
ModerationApi	deleteModerationVote	DELETE /auth/my-account/moderate-comments/mod_api/vote/{commentId}/{voteId}
ModerationApi	getApiComments	GET /auth/my-account/moderate-comments/mod_api/api/comments
ModerationApi	getApiExportStatus	GET /auth/my-account/moderate-comments/mod_api/api/export/status
ModerationApi	getApiIds	GET /auth/my-account/moderate-comments/mod_api/api/ids
ModerationApi	getBanUsersFromComment	GET /auth/my-account/moderate-comments/mod_api/ban-users/from-comment/{commentId}
ModerationApi	getCommentBanStatus	GET /auth/my-account/moderate-comments/mod_api/get-comment-ban-status/{commentId}
ModerationApi	getCommentChildren	GET /auth/my-account/moderate-comments/mod_api/comment-children/{commentId}
ModerationApi	getCount	GET /auth/my-account/moderate-comments/mod_api/count
ModerationApi	getCounts	GET /auth/my-account/moderate-comments/banned-users/mod_api/counts
ModerationApi	getLogs	GET /auth/my-account/moderate-comments/mod_api/logs/{commentId}
ModerationApi	getManualBadges	GET /auth/my-account/moderate-comments/mod_api/get-manual-badges
ModerationApi	getManualBadgesForUser	GET /auth/my-account/moderate-comments/mod_api/get-manual-badges-for-user
ModerationApi	getModerationComment	GET /auth/my-account/moderate-comments/mod_api/comment/{commentId}
ModerationApi	getModerationCommentText	GET /auth/my-account/moderate-comments/mod_api/get-comment-text/{commentId}
ModerationApi	getPreBanSummary	GET /auth/my-account/moderate-comments/mod_api/pre-ban-summary/{commentId}
ModerationApi	getSearchCommentsSummary	GET /auth/my-account/moderate-comments/mod_api/search/comments/summary
ModerationApi	getSearchPages	GET /auth/my-account/moderate-comments/mod_api/search/pages
ModerationApi	getSearchSites	GET /auth/my-account/moderate-comments/mod_api/search/sites
ModerationApi	getSearchSuggest	GET /auth/my-account/moderate-comments/mod_api/search/suggest
ModerationApi	getSearchUsers	GET /auth/my-account/moderate-comments/mod_api/search/users
ModerationApi	getTrustFactor	GET /auth/my-account/moderate-comments/mod_api/get-trust-factor
ModerationApi	getUserBanPreference	GET /auth/my-account/moderate-comments/mod_api/user-ban-preference
ModerationApi	getUserInternalProfile	GET /auth/my-account/moderate-comments/mod_api/get-user-internal-profile
ModerationApi	postAdjustCommentVotes	POST /auth/my-account/moderate-comments/mod_api/adjust-comment-votes/{commentId}
ModerationApi	postApiExport	POST /auth/my-account/moderate-comments/mod_api/api/export
ModerationApi	postBanUserFromComment	POST /auth/my-account/moderate-comments/mod_api/ban-user/from-comment/{commentId}
ModerationApi	postBanUserUndo	POST /auth/my-account/moderate-comments/mod_api/ban-user/undo
ModerationApi	postBulkPreBanSummary	POST /auth/my-account/moderate-comments/mod_api/bulk-pre-ban-summary
ModerationApi	postCommentsByIds	POST /auth/my-account/moderate-comments/mod_api/comments-by-ids
ModerationApi	postFlagComment	POST /auth/my-account/moderate-comments/mod_api/flag-comment/{commentId}
ModerationApi	postRemoveComment	POST /auth/my-account/moderate-comments/mod_api/remove-comment/{commentId}
ModerationApi	postRestoreDeletedComment	POST /auth/my-account/moderate-comments/mod_api/restore-deleted-comment/{commentId}
ModerationApi	postSetCommentApprovalStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-approval-status/{commentId}
ModerationApi	postSetCommentReviewStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-review-status/{commentId}
ModerationApi	postSetCommentSpamStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-spam-status/{commentId}
ModerationApi	postSetCommentText	POST /auth/my-account/moderate-comments/mod_api/set-comment-text/{commentId}
ModerationApi	postUnFlagComment	POST /auth/my-account/moderate-comments/mod_api/un-flag-comment/{commentId}
ModerationApi	postVote	POST /auth/my-account/moderate-comments/mod_api/vote/{commentId}
ModerationApi	putAwardBadge	PUT /auth/my-account/moderate-comments/mod_api/award-badge
ModerationApi	putCloseThread	PUT /auth/my-account/moderate-comments/mod_api/close-thread
ModerationApi	putRemoveBadge	PUT /auth/my-account/moderate-comments/mod_api/remove-badge
ModerationApi	putReopenThread	PUT /auth/my-account/moderate-comments/mod_api/reopen-thread
ModerationApi	setTrustFactor	PUT /auth/my-account/moderate-comments/mod_api/set-trust-factor
PublicApi	blockFromCommentPublic	POST /block-from-comment/{commentId}
PublicApi	checkedCommentsForBlocked	GET /check-blocked-comments
PublicApi	createCommentPublic	POST /comments/{tenantId}
PublicApi	createFeedPostPublic	POST /feed-posts/{tenantId}
PublicApi	createV1PageReact	POST /page-reacts/v1/likes/{tenantId}
PublicApi	createV2PageReact	POST /page-reacts/v2/{tenantId}
PublicApi	deleteCommentPublic	DELETE /comments/{tenantId}/{commentId}
PublicApi	deleteCommentVote	DELETE /comments/{tenantId}/{commentId}/vote/{voteId}
PublicApi	deleteFeedPostPublic	DELETE /feed-posts/{tenantId}/{postId}
PublicApi	deleteV1PageReact	DELETE /page-reacts/v1/likes/{tenantId}
PublicApi	deleteV2PageReact	DELETE /page-reacts/v2/{tenantId}
PublicApi	flagCommentPublic	POST /flag-comment/{commentId}
PublicApi	getCommentText	GET /comments/{tenantId}/{commentId}/text
PublicApi	getCommentVoteUserNames	GET /comments/{tenantId}/{commentId}/votes
PublicApi	getCommentsForUser	GET /comments-for-user
PublicApi	getCommentsPublic	GET /comments/{tenantId}	req tenantId urlId
PublicApi	getEventLog	GET /event-log/{tenantId}	req tenantId urlId userIdWS
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	req tenantId afterId
PublicApi	getFeedPostsStats	GET /feed-posts/{tenantId}/stats
PublicApi	getGifLarge	GET /gifs/get-large/{tenantId}
PublicApi	getGifsSearch	GET /gifs/search/{tenantId}
PublicApi	getGifsTrending	GET /gifs/trending/{tenantId}
PublicApi	getGlobalEventLog	GET /event-log/global/{tenantId}	req tenantId urlId userIdWS
PublicApi	getOfflineUsers	GET /pages/{tenantId}/users/offline	Comentadores anteriores na página que NÃO estão atualmente online. Ordenados por displayName. Use isso após esgotar /users/online para renderizar uma seção "Membros". Paginação por cursor em commenterName: o servidor percorre o índice parcial {tenantId, urlId, commenterName} a partir de afterName avançando via $gt, sem custo $skip.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	Visualizadores atualmente online de uma página: pessoas cuja sessão de websocket está inscrita na página neste momento. Retorna anonCount + totalCount (assinantes de todo o quarto, incluindo visualizadores anônimos que não enumeramos).
PublicApi	getPagesPublic	GET /pages/{tenantId}	Lista páginas para um tenant. Usado pelo cliente desktop FChat para preencher sua lista de salas. Requer que `enableFChat` seja true na configuração personalizada resolvida para cada página. Páginas que requerem SSO são filtradas de acordo com o acesso de grupo do usuário solicitante.
PublicApi	getTranslations	GET /translations/{namespace}/{component}
PublicApi	getUserNotificationCount	GET /user-notifications/get-count
PublicApi	getUserNotifications	GET /user-notifications
PublicApi	getUserPresenceStatuses	GET /user-presence-status
PublicApi	getUserReactsPublic	GET /feed-posts/{tenantId}/user-reacts
PublicApi	getUsersInfo	GET /pages/{tenantId}/users/info	Bulk user info for a tenant. Given userIds, return display info from User / SSOUser. Used by the comment widget to enrich users that just appeared via a presence event. No page context: privacy is enforced uniformly (private profiles are masked).
PublicApi	getV1PageLikes	GET /page-reacts/v1/likes/{tenantId}
PublicApi	getV2PageReactUsers	GET /page-reacts/v2/{tenantId}/list
PublicApi	getV2PageReacts	GET /page-reacts/v2/{tenantId}
PublicApi	lockComment	POST /comments/{tenantId}/{commentId}/lock
PublicApi	logoutPublic	PUT /auth/logout
PublicApi	pinComment	POST /comments/{tenantId}/{commentId}/pin
PublicApi	reactFeedPostPublic	POST /feed-posts/{tenantId}/react/{postId}
PublicApi	resetUserNotificationCount	POST /user-notifications/reset-count
PublicApi	resetUserNotifications	POST /user-notifications/reset
PublicApi	searchUsers	GET /user-search/{tenantId}
PublicApi	setCommentText	POST /comments/{tenantId}/{commentId}/update-text
PublicApi	unBlockCommentPublic	DELETE /block-from-comment/{commentId}
PublicApi	unLockComment	POST /comments/{tenantId}/{commentId}/unlock
PublicApi	unPinComment	POST /comments/{tenantId}/{commentId}/unpin
PublicApi	updateFeedPostPublic	PUT /feed-posts/{tenantId}/{postId}
PublicApi	updateUserNotificationCommentSubscriptionStatus	POST /user-notifications/{notificationId}/mark-opted/{optedInOrOut}	Enable or disable notifications for a specific comment.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Enable or disable notifications for a page. When users are subscribed to a page, notifications are created for new root comments, and also
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Upload and resize an image
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Documentação para Modelos

aggregate

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

Parameters

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

Response

Returns: AggregateResponse

Example

Exemplo de agregação

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();
            // processar resposta
        } catch (const std::exception& e) {
            // tratar erro
        }
    });

getAuditLogs

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Yes
options	const GetAuditLogsOptions&	Yes

Resposta

Retorna: GetAuditLogsResponse

Exemplo

Exemplo 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();
        // usar a resposta
    } catch (const std::exception& e) {
        // tratar erro
    }
});

logoutPublic

Resposta

Retorna: APIEmptyResponse

Exemplo

logoutPublic Exemplo

Copy

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

blockFromCommentPublic

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
publicBlockFromCommentParams	PublicBlockFromCommentParams	Sim
sso	string	Não

Resposta

Retorna: BlockSuccess

Exemplo

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

unBlockCommentPublic

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
publicBlockFromCommentParams	PublicBlockFromCommentParams	Sim
sso	string	Não

Resposta

Retorna: UnblockSuccess

Exemplo

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

checkedCommentsForBlocked

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentIds	string	Sim
sso	string	Não

Resposta

Retorna: CheckBlockedCommentsResponse

Exemplo

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

blockUserFromComment

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
blockFromCommentParams	BlockFromCommentParams	Sim
options	const BlockUserFromCommentOptions&	Sim

Resposta

Retorna: BlockSuccess

Exemplo

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

createCommentPublic

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
urlId	string	Sim
broadcastId	string	Sim
commentData	CommentData	Sim
options	const CreateCommentPublicOptions&	Sim

Resposta

Retorna: SaveCommentsResponseWithPresence

Exemplo

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

deleteComment

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
options	const DeleteCommentOptions&	Sim

Resposta

Retorna: DeleteCommentResult

Exemplo

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

deleteCommentPublic

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
broadcastId	string	Sim
options	const DeleteCommentPublicOptions&	Sim

Resposta

Retorna: PublicAPIDeleteCommentResponse

Exemplo

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

deleteCommentVote

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
voteId	string	Sim
urlId	string	Sim
broadcastId	string	Sim
options	const DeleteCommentVoteOptions&	Sim

Resposta

Retorna: VoteDeleteResponse

Exemplo

deleteCommentVote Exemplo

Copy

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

flagComment

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
options	const FlagCommentOptions&	Sim

Resposta

Retorna: FlagCommentResponse

Exemplo

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

getComment

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Resposta

Retorna: APIGetCommentResponse

Exemplo

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

getComments

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetCommentsOptions&	Sim

Resposta

Retorna: APIGetCommentsResponse

Exemplo

Exemplo 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();
        // use a resposta conforme necessário
    } catch (const std::exception& e) {
        // trate o erro
    }
});

getCommentsPublic

req tenantId urlId

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
urlId	string	Sim
options	const GetCommentsPublicOptions&	Sim

Resposta

Retorna: GetCommentsResponseWithPresence_PublicComment_

Exemplo

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

getCommentText

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
options	const GetCommentTextOptions&	Sim

Resposta

Retorna: PublicAPIGetCommentTextResponse

Exemplo

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

getCommentVoteUserNames

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
dir	int32_t	Sim
sso	string	Não

Resposta

Retorna: GetCommentVoteUserNamesSuccessResponse

Exemplo

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

lockComment

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
broadcastId	string	Sim
sso	string	Não

Resposta

Retorna: APIEmptyResponse

Exemplo

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

pinComment

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Resposta

Retorna: ChangeCommentPinStatusResponse

Exemplo

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

saveComment

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
createCommentParams	CreateCommentParams	Yes
options	const SaveCommentOptions&	Yes

Resposta

Retorna: APISaveCommentResponse

Exemplo

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

setCommentText

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
broadcastId	string	Sim
commentTextUpdateRequest	CommentTextUpdateRequest	Sim
options	const SetCommentTextOptions&	Sim

Resposta

Retorna: PublicAPISetCommentTextResponse

Exemplo

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

unBlockUserFromComment

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
id	string	Yes
unBlockFromCommentParams	UnBlockFromCommentParams	Yes
options	const UnBlockUserFromCommentOptions&	Yes

Resposta

Retorna: UnblockSuccess

Exemplo

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

unFlagComment

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
options	const UnFlagCommentOptions&	Sim

Resposta

Retorna: FlagCommentResponse

Exemplo

Exemplo 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;
            // processar status se necessário
        }
    })
    .then([](pplx::task<void> previous) {
        try {
            previous.get();
        } catch (const std::exception& e) {
            // tratar erro
        }
    });

unLockComment

Parâmetros

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

Resposta

Retorna: APIEmptyResponse

Exemplo

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

unPinComment

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
broadcastId	string	Sim
sso	string	Não

Resposta

Retorna: ChangeCommentPinStatusResponse

Exemplo

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

updateComment

Parameters

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
updatableCommentParams	UpdatableCommentParams	Sim
options	const UpdateCommentOptions&	Sim

Response

Retorna: APIEmptyResponse

Example

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

voteComment

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
urlId	string	Sim
broadcastId	string	Sim
voteBodyParams	VoteBodyParams	Sim
options	const VoteCommentOptions&	Sim

Resposta

Retorna: VoteResponse

Exemplo

Exemplo 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();
           // lidar com a resposta
       } catch (const std::exception&) {
       }
   });

getCommentsForUser

Parâmetros

Nome	Tipo	Obrigatório	Descrição
options	const GetCommentsForUserOptions&	Sim

Resposta

Retorna: GetCommentsForUserResponse

Exemplo

getCommentsForUser Exemplo

Copy

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

addDomainConfig

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
addDomainConfigParams	AddDomainConfigParams	Sim

Resposta

Retorna: AddDomainConfigResponse

Exemplo

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

deleteDomainConfig

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
domain	string	Sim

Resposta

Returns: DeleteDomainConfigResponse

Exemplo

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

getDomainConfig

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
domain	string	Sim

Resposta

Retorna: GetDomainConfigResponse

Exemplo

Exemplo 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) {
            // handle enabled moderation
        }
        if (theme) {
            // use theme value
        }
    })
    .wait();

getDomainConfigs

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim

Resposta

Retorna: GetDomainConfigsResponse

Exemplo

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

patchDomainConfig

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
domainToUpdate	string	Sim
patchDomainConfigParams	PatchDomainConfigParams	Sim

Resposta

Retorna: PatchDomainConfigResponse

Exemplo

Exemplo 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) {
        // tratamento de sucesso
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* tratamento de erro */ }
    });

putDomainConfig

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
domainToUpdate	string	Sim
updateDomainConfigParams	UpdateDomainConfigParams	Sim

Resposta

Retorna: PutDomainConfigResponse

Exemplo

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

createEmailTemplate

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
createEmailTemplateBody	CreateEmailTemplateBody	Sim

Resposta

Retorna: CreateEmailTemplateResponse

Exemplo

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

deleteEmailTemplate

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Resposta

Retorna: APIEmptyResponse

Exemplo

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

deleteEmailTemplateRenderError

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
errorId	string	Sim

Resposta

Retorna: APIEmptyResponse

Exemplo

deleteEmailTemplateRenderError Exemplo

Copy

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

getEmailTemplate

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Resposta

Retorna: GetEmailTemplateResponse

Exemplo

Exemplo getEmailTemplate

Copy

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

getEmailTemplateDefinitions

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim

Resposta

Retorna: GetEmailTemplateDefinitionsResponse

Exemplo

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

getEmailTemplateRenderErrors

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
skip	double	Não

Resposta

Retorna: GetEmailTemplateRenderErrorsResponse

Exemplo

getEmailTemplateRenderErrors Exemplo

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();
            // Use a resposta conforme necessário
        } catch (const std::exception& ex) {
            // Trate o erro
        }
    });

getEmailTemplates

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
skip	double	Não

Resposta

Retorna: GetEmailTemplatesResponse

Exemplo

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

renderEmailTemplate

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
renderEmailTemplateBody	RenderEmailTemplateBody	Sim
locale	string	Não

Resposta

Retorna: RenderEmailTemplateResponse

Exemplo

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

updateEmailTemplate

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
id	string	Yes
updateEmailTemplateBody	UpdateEmailTemplateBody	Yes

Resposta

Retorna: APIEmptyResponse

Exemplo

Exemplo 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) {
        // manipulação de sucesso
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception &) { /* manipulação de erro */ }
    });

getEventLog

req tenantId urlId userIdWS

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
urlId	string	Sim
userIdWS	string	Sim
startTime	int64_t	Sim
endTime	int64_t	Não

Resposta

Retorna: GetEventLogResponse

Exemplo

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

getGlobalEventLog

req tenantId urlId userIdWS

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
urlId	string	Sim
userIdWS	string	Sim
startTime	int64_t	Sim
endTime	int64_t	Não

Resposta

Retorna: GetEventLogResponse

Exemplo

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

createFeedPost

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
createFeedPostParams	CreateFeedPostParams	Sim
options	const CreateFeedPostOptions&	Sim

Resposta

Retorna: CreateFeedPostsResponse

Exemplo

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

createFeedPostPublic

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
createFeedPostParams	CreateFeedPostParams	Sim
options	const CreateFeedPostPublicOptions&	Sim

Resposta

Retorna: CreateFeedPostResponse

Exemplo

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

deleteFeedPostPublic

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
postId	string	Sim
options	const DeleteFeedPostPublicOptions&	Sim

Resposta

Retorna: DeleteFeedPostPublicResponse

Exemplo

deleteFeedPostPublic Exemplo

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()) {
            // lógica de sucesso
        }
    });

getFeedPosts

req tenantId afterId

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetFeedPostsOptions&	Sim

Resposta

Retorna: GetFeedPostsResponse

Exemplo

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

getFeedPostsPublic

req
tenantId
afterId

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetFeedPostsPublicOptions&	Sim

Resposta

Retorna: PublicFeedPostsResponse

Exemplo

Exemplo 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);  
        // Use o processado conforme necessário  
    }catch(const std::exception&){  
        // Trate o erro  
    }  
});  

getFeedPostsStats

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
postIds	vector<string	Sim
sso	string	Não

Resposta

Retorna: FeedPostsStatsResponse

Exemplo

Exemplo getFeedPostsStats

Copy

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

getUserReactsPublic

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetUserReactsPublicOptions&	Sim

Resposta

Retorna: UserReactsResponse

Exemplo

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

reactFeedPostPublic

Parameters

Name	Type	Required
tenantId	string	Sim
postId	string	Sim
reactBodyParams	ReactBodyParams	Sim
options	const ReactFeedPostPublicOptions&	Sim

Response

Retorna: ReactFeedPostResponse

Exemplo

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

updateFeedPost

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
id	string	Yes
feedPost	FeedPost	Yes

Resposta

Retorna: APIEmptyResponse

Exemplo

updateFeedPost Exemplo

Copy

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

updateFeedPostPublic

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
postId	string	Sim
updateFeedPostParams	UpdateFeedPostParams	Sim
options	const UpdateFeedPostPublicOptions&	Sim

Resposta

Retorna: CreateFeedPostResponse

Exemplo

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

flagCommentPublic

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
isFlagged	bool	Sim
sso	string	Não

Resposta

Retorna: APIEmptyResponse

Exemplo

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

getGifLarge

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
largeInternalURLSanitized	string	Sim

Resposta

Retorna: GifGetLargeResponse

Exemplo

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

getGifsSearch

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
search	string	Sim
options	const GetGifsSearchOptions&	Sim

Resposta

Retorna: GetGifsSearchResponse

Exemplo

getGifsSearch Exemplo

Copy

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

getGifsTrending

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetGifsTrendingOptions&	Sim

Resposta

Retorna: GetGifsTrendingResponse

Exemplo

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

addHashTag

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
createHashTagBody	CreateHashTagBody	Sim

Resposta

Retorna: CreateHashTagResponse

Exemplo

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

addHashTagsBulk

Parâmetros

Name	Type	Required	Description
tenantId	string	Yes
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Yes

Resposta

Retorna: BulkCreateHashTagsResponse

Exemplo

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

deleteHashTag

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
tag	string	Sim
deleteHashTagRequestBody	DeleteHashTagRequestBody	Sim

Resposta

Retorna: APIEmptyResponse

Exemplo

deleteHashTag Exemplo

Copy

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

getHashTags

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
page	double	Não

Resposta

Retorna: GetHashTagsResponse

Exemplo

Exemplo 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);
        // usar a resposta
    } catch (const std::exception&) {
        // tratar erro
    }
});

patchHashTag

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
tag	string	Sim
updateHashTagBody	UpdateHashTagBody	Sim

Resposta

Retorna: UpdateHashTagResponse

Exemplo

patchHashTag Exemplo

Copy

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

deleteModerationVote

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
voteId	string	Sim
options	const DeleteModerationVoteOptions&	Sim

Resposta

Retorna: VoteDeleteResponse

Exemplo

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

getApiComments

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetApiCommentsOptions&	Sim

Resposta

Retorna: ModerationAPIGetCommentsResponse

Exemplo

Exemplo getApiComments

Copy

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

getApiExportStatus

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetApiExportStatusOptions&	Sim

Resposta

Retorna: ModerationExportStatusResponse

Exemplo

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

getApiIds

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetApiIdsOptions&	Sim

Resposta

Retorna: ModerationAPIGetCommentIdsResponse

Exemplo

Exemplo getApiIds

Copy

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

getBanUsersFromComment

Parâmetros

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

Resposta

Retorna: GetBannedUsersFromCommentResponse

Exemplo

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

getCommentBanStatus

Parâmetros

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

Resposta

Retorna: GetCommentBanStatusResponse

Exemplo

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

getCommentChildren

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
sso	string	Não

Resposta

Retorna: ModerationAPIChildCommentsResponse

Exemplo

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

getCount

Parâmetros

Name	Type	Required	Description
tenantId	string	Sim
options	const GetCountOptions&	Sim

Resposta

Retorna: ModerationAPICountCommentsResponse

Exemplo

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

getCounts

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
sso	string	Não

Resposta

Retorna: GetBannedUsersCountResponse

Exemplo

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

getLogs

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
sso	string	Não

Resposta

Retorna: ModerationAPIGetLogsResponse

Exemplo

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

getManualBadges

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
sso	string	Não

Resposta

Retorna: GetTenantManualBadgesResponse

Exemplo

Exemplo 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();
            // processar resposta, por exemplo, response->badgeList
        } catch (const std::exception& ex) {
            // tratar erro
        }
    });

getManualBadgesForUser

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetManualBadgesForUserOptions&	Sim

Resposta

Retorna: GetUserManualBadgesResponse

Exemplo

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

getModerationComment

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
options	const GetModerationCommentOptions&	Sim

Resposta

Retorna: ModerationAPICommentResponse

Exemplo

Exemplo 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();
            // Processar resposta conforme necessário
        } catch (const std::exception& ex) {
            // Tratar erro
        }
    });

getModerationCommentText

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Resposta

Retorna: GetCommentTextResponse

Exemplo

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

getPreBanSummary

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
options	const GetPreBanSummaryOptions&	Sim

Resposta

Retorna: PreBanSummary

Exemplo

Exemplo 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();
            // processar resumo
        } catch (const std::exception&) {
            // tratar erro
        }
    });

getSearchCommentsSummary

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetSearchCommentsSummaryOptions&	Sim

Resposta

Retorna: ModerationCommentSearchResponse

Exemplo

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

getSearchPages

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetSearchPagesOptions&	Sim

Resposta

Retorna: ModerationPageSearchResponse

Exemplo

Exemplo 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();
            // usar a resposta
        } catch (const std::exception& e) {
            // tratar erro
        }
    });

getSearchSites

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetSearchSitesOptions&	Sim

Resposta

Retorna: ModerationSiteSearchResponse

Exemplo

Exemplo 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) {
               // lógica de processamento
           }
       } catch (const std::exception&) {
           // tratamento de erro
       }
   });

getSearchSuggest

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetSearchSuggestOptions&	Sim

Resposta

Retorna: ModerationSuggestResponse

Exemplo

getSearchSuggest Exemplo

Copy

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

getSearchUsers

Parameters

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetSearchUsersOptions&	Sim

Response

Retorna: ModerationUserSearchResponse

Example

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

getTrustFactor

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetTrustFactorOptions&	Sim

Resposta

Retorna: GetUserTrustFactorResponse

Exemplo

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

getUserBanPreference

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
sso	string	Não

Resposta

Retorna: APIModerateGetUserBanPreferencesResponse

Exemplo

Exemplo getUserBanPreference

Copy

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

getUserInternalProfile

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetUserInternalProfileOptions&	Sim

Resposta

Retorna: GetUserInternalProfileResponse

Exemplo

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

postAdjustCommentVotes

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
adjustCommentVotesParams	AdjustCommentVotesParams	Sim
options	const PostAdjustCommentVotesOptions&	Sim

Resposta

Retorna: AdjustVotesResponse

Exemplo

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

postApiExport

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const PostApiExportOptions&	Sim

Respota

Retorna: ModerationExportResponse

Exemplo

postApiExport Exemplo

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) {
            // lidar com a resposta de exportação bem-sucedida
        }
    })
    .wait();

postBanUserFromComment

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
options	const PostBanUserFromCommentOptions&	Sim

Resposta

Retorna: BanUserFromCommentResult

Exemplo

postBanUserFromComment Exemplo

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) {
        // tratamento do resultado
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* tratamento de erro */ }
    });

postBanUserUndo

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
banUserUndoParams	BanUserUndoParams	Sim
sso	string	Não

Resposta

Retorna: APIEmptyResponse

Exemplo

Exemplo 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){
    // lidar com sucesso
});

postBulkPreBanSummary

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
bulkPreBanParams	BulkPreBanParams	Sim
options	const PostBulkPreBanSummaryOptions&	Sim

Resposta

Retorna: BulkPreBanSummary

Exemplo

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

postCommentsByIds

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentsByIdsParams	CommentsByIdsParams	Sim
sso	string	Não

Resposta

Retorna: ModerationAPIChildCommentsResponse

Exemplo

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

postFlagComment

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
options	const PostFlagCommentOptions&	Sim

Resposta

Retorna: APIEmptyResponse

Exemplo

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

postRemoveComment

Parâmetros

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

Resposta

Retorna: PostRemoveCommentApiResponse

Exemplo

postRemoveComment Exemplo

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();
            // Processar resposta
        } catch (const std::exception& ex) {
            // Tratar erro
        }
    });

postRestoreDeletedComment

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
commentId	string	Yes
options	const PostRestoreDeletedCommentOptions&	Yes

Resposta

Returns: APIEmptyResponse

Exemplo

postRestoreDeletedComment Exemplo

Copy

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

postSetCommentApprovalStatus

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentApprovalStatusOptions&	Yes

Resposta

Retorna: SetCommentApprovedResponse

Exemplo

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

postSetCommentReviewStatus

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
options	const PostSetCommentReviewStatusOptions&	Sim

Resposta

Retorna: APIEmptyResponse

Exemplo

postSetCommentReviewStatus Exemplo

Copy

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

postSetCommentSpamStatus

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
options	const PostSetCommentSpamStatusOptions&	Sim

Resposta

Retorna: APIEmptyResponse

Exemplo

postSetCommentSpamStatus Exemplo

Copy

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

postSetCommentText

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
commentId	string	Yes
setCommentTextParams	SetCommentTextParams	Yes
options	const PostSetCommentTextOptions&	Yes

Resposta

Retorna: SetCommentTextResponse

Exemplo

postSetCommentText Exemplo

Copy

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

postUnFlagComment

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
commentId	string	Yes
options	const PostUnFlagCommentOptions&	Yes

Resposta

Returns: APIEmptyResponse

Exemplo

postUnFlagComment Exemplo

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) {
        // o processamento pode ser feito aqui
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

postVote

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
options	const PostVoteOptions&	Sim

Resposta

Retorna: VoteResponse

Exemplo

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

putAwardBadge

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
badgeId	string	Sim
options	const PutAwardBadgeOptions&	Sim

Resposta

Retorna: AwardUserBadgeResponse

Exemplo

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

putCloseThread

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
urlId	string	Sim
sso	string	Não

Resposta

Retorna: APIEmptyResponse

Exemplo

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

putRemoveBadge

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
badgeId	string	Yes
options	const PutRemoveBadgeOptions&	Yes

Resposta

Retorna: RemoveUserBadgeResponse

Exemplo

putRemoveBadge Exemplo

Copy

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

putReopenThread

Parâmetros

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

Resposta

Retorna: APIEmptyResponse

Exemplo

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

setTrustFactor

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const SetTrustFactorOptions&	Sim

Resposta

Retorna: SetUserTrustFactorResponse

Exemplo

setTrustFactor Exemplo

Copy

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

createModerator

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
createModeratorBody	CreateModeratorBody	Sim

Resposta

Retorna: CreateModeratorResponse

Exemplo

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

deleteModerator

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
sendEmail	string	Não

Resposta

Retorna: APIEmptyResponse

Exemplo

Exemplo 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) {
        // tratar sucesso
    });

getModerator

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Resposta

Retorna: GetModeratorResponse

Exemplo

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

getModerators

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
skip	double	Não

Resposta

Retorna: GetModeratorsResponse

Exemplo

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

sendInvite

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
fromName	string	Sim

Resposta

Retorna: APIEmptyResponse

Exemplo

sendInvite Exemplo

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) {
    // lidar com convite bem-sucedido
});

updateModerator

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
updateModeratorBody	UpdateModeratorBody	Sim

Resposta

Retorna: APIEmptyResponse

Exemplo

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

deleteNotificationCount

Parameters

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Response

Retorna: APIEmptyResponse

Example

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

getCachedNotificationCount

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Resposta

Retorna: GetCachedNotificationCountResponse

Exemplo

Exemplo 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();
            // processar a resposta
        } catch (const std::exception&) {
            // tratar erro
        }
    });

getNotificationCount

Parâmetros

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

Resposta

Retorna: GetNotificationCountResponse

Exemplo

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

getNotifications

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetNotificationsOptions&	Sim

Resposta

Retorna: GetNotificationsResponse

Exemplo

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

updateNotification

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
updateNotificationBody	UpdateNotificationBody	Sim
userId	string	Não

Resposta

Retorna: APIEmptyResponse

Exemplo

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

createV1PageReact

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
urlId	string	Sim
title	string	Não

Resposta

Retorna: CreateV1PageReact

Exemplo

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

createV2PageReact

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
urlId	string	Sim
id	string	Sim
title	string	Não

Resposta

Retorna: CreateV1PageReact

Exemplo

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

deleteV1PageReact

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
urlId	string	Sim

Resposta

Retorna: CreateV1PageReact

Exemplo

deleteV1PageReact Exemplo

Copy

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

deleteV2PageReact

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
urlId	string	Sim
id	string	Sim

Resposta

Retorna: CreateV1PageReact

Exemplo

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

getV1PageLikes

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
urlId	string	Sim

Resposta

Retorna: GetV1PageLikes

Exemplo

getV1PageLikes Exemplo

Copy

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

getV2PageReacts

Parâmetros

Name	Type	Required	Description
tenantId	string	Yes
urlId	string	Yes

Resposta

Retorna: GetV2PageReacts

Exemplo

getV2PageReacts Exemplo

Copy

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

getV2PageReactUsers

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
urlId	string	Yes
id	string	Yes

Resposta

Retorna: GetV2PageReactUsersResponse

Exemplo

Exemplo 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();
        // Use a resposta conforme necessário
    }catch(const std::exception&){
        // Trate o erro
    }
});

addPage

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
createAPIPageData	CreateAPIPageData	Sim

Resposta

Retorna: AddPageAPIResponse

Exemplo

Exemplo 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) {
            // lidar com adição bem-sucedida
        } else {
            // lidar com erro
        }
    });

deletePage

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Resposta

Retorna: DeletePageAPIResponse

Exemplo

Exemplo de 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();
           // processar a resposta conforme necessário
       } catch (const std::exception& ex) {
           // tratar erro
       }
   });

getOfflineUsers

Passados comentadores na página que NÃO estão atualmente online. Ordenados por displayName.
Use isso depois de esgotar /users/online para renderizar uma seção “Members”.
Paginação por cursor em commenterName: o servidor percorre o parcial {tenantId, urlId, commenterName}
índice a partir de afterName avançando via $gt, sem custo de $skip.

Parameters

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

Response

Retorna: PageUsersOfflineResponse

Example

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

getOnlineUsers

Visualizadores atualmente online de uma página: pessoas cuja sessão websocket está assinada à página neste momento.
Retorna anonCount + totalCount (assinantes de toda a sala, incluindo visualizadores anônimos que não enumeramos).

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
urlId	string	Sim
options	const GetOnlineUsersOptions&	Sim

Resposta

Retorna: PageUsersOnlineResponse

Exemplo

Exemplo getOnlineUsers

Copy

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

getPageByURLId

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
urlId	string	Sim

Resposta

Retorna: GetPageByURLIdAPIResponse

Exemplo

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

getPages

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim

Resposta

Retorna: GetPagesAPIResponse

Exemplo

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

getPagesPublic

List pages for a tenant. Used by the FChat desktop client to populate its room list.
Requer 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

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetPagesPublicOptions&	Sim

Response

Retorna: GetPublicPagesResponse

Exemplo

Exemplo 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();
        // processar a resposta se necessário
    }catch(const std::exception&){
        // tratar erro se necessário
    }
});

getUsersInfo

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

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
ids	string	Sim

Resposta

Retorna: PageUsersInfoResponse

Exemplo

Exemplo 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();
        // processar resposta
    }catch(const std::exception&){
        // tratar erro
    }
});

patchPage

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
updateAPIPageData	UpdateAPIPageData	Sim

Resposta

Retorna: PatchPageAPIResponse

Exemplo

Exemplo 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) {
            // lidar com sucesso
        }
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

deletePendingWebhookEvent

Parameters

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Response

Retorna: APIEmptyResponse

Exemplo

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

getPendingWebhookEventCount

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetPendingWebhookEventCountOptions&	Sim

Resposta

Retorna: GetPendingWebhookEventCountResponse

Exemplo

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

getPendingWebhookEvents

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetPendingWebhookEventsOptions&	Sim

Resposta

Retorna: GetPendingWebhookEventsResponse

Exemplo

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

createQuestionConfig

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
createQuestionConfigBody	CreateQuestionConfigBody	Sim

Resposta

Retorna: CreateQuestionConfigResponse

Exemplo

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

deleteQuestionConfig

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Resposta

Retorna: APIEmptyResponse

Exemplo

Exemplo 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) {
        // tratar exclusão bem-sucedida
    })
    .then([](pplx::task<void> t) {
        try {
            t.get();
        } catch (const std::exception&) {
            // tratar erro
        }
    });

getQuestionConfig

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Resposta

Retorna: GetQuestionConfigResponse

Exemplo

Exemplo 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();
            // Use a resposta conforme necessário
        } catch (const std::exception&) {
            // Tratar erro
        }
    });

getQuestionConfigs

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
skip	double	Não

Resposta

Retorna: GetQuestionConfigsResponse

Exemplo

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

updateQuestionConfig

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
id	string	Yes
updateQuestionConfigBody	UpdateQuestionConfigBody	Yes

Resposta

Retorna: APIEmptyResponse

Exemplo

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

createQuestionResult

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
createQuestionResultBody	CreateQuestionResultBody	Sim

Resposta

Retorna: CreateQuestionResultResponse

Exemplo

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

deleteQuestionResult

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Yes
id	string	Yes

Resposta

Returns: APIEmptyResponse

Exemplo

Exemplo 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();
                // tratamento de sucesso
            }
            catch ( const std::exception& e )
            {
                // tratamento de erro
            }
        } );
}

getQuestionResult

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Resposta

Retorna: GetQuestionResultResponse

Exemplo

Exemplo getQuestionResult

Copy

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

getQuestionResults

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetQuestionResultsOptions&	Sim

Resposta

Retorna: GetQuestionResultsResponse

Exemplo

Exemplo 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();
        // lidar com a resposta
    });

updateQuestionResult

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
updateQuestionResultBody	UpdateQuestionResultBody	Sim

Resposta

Retorna: APIEmptyResponse

Exemplo

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

aggregateQuestionResults

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const AggregateQuestionResultsOptions&	Sim

Resposta

Retorna: AggregateQuestionResultsResponse

Exemplo

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

bulkAggregateQuestionResults

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Sim
forceRecalculate	bool	Não

Resposta

Retorna: BulkAggregateQuestionResultsResponse

Exemplo

bulkAggregateQuestionResults Exemplo

Copy

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

combineCommentsWithQuestionResults

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const CombineCommentsWithQuestionResultsOptions&	Sim

Resposta

Retorna: CombineQuestionResultsWithCommentsResponse

Exemplo

Exemplo 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);
            // Use combined conforme necessário
        }catch(const std::exception&){
        }
    });

addSSOUser

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
createAPISSOUserData	CreateAPISSOUserData	Sim

Resposta

Retorna: AddSSOUserAPIResponse

Exemplo

addSSOUser Exemplo

Copy

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

deleteSSOUser

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
id	string	Yes
options	const DeleteSSOUserOptions&	Yes

Resposta

Retorna: DeleteSSOUserAPIResponse

Exemplo

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

getSSOUserByEmail

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
email	string	Sim

Resposta

Retorna: GetSSOUserByEmailAPIResponse

Exemplo

Exemplo getSSOUserByEmail

Copy

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

getSSOUserById

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Resposta

Retorna: GetSSOUserByIdAPIResponse

Exemplo

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

getSSOUsers

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
skip	int32_t	Não

Resposta

Retorna: GetSSOUsersResponse

Exemplo

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

patchSSOUser

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
id	string	Yes
updateAPISSOUserData	UpdateAPISSOUserData	Yes
updateComments	bool	No

Resposta

Retorna: PatchSSOUserAPIResponse

Exemplo

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

putSSOUser

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
id	string	Yes
updateAPISSOUserData	UpdateAPISSOUserData	Yes
updateComments	bool	No

Resposta

Retorna: PutSSOUserAPIResponse

Exemplo

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

createSubscription

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Sim

Resposta

Retorna: CreateSubscriptionAPIResponse

Exemplo

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

deleteSubscription

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
userId	string	Não

Resposta

Retorna: DeleteSubscriptionAPIResponse

Exemplo

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

getSubscriptions

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
userId	string	Não

Resposta

Retorna: GetSubscriptionsAPIResponse

Exemplo

Exemplo 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();
            // processar resposta
        } catch (const std::exception& e) {
            // tratar erro
        }
    }
);

updateSubscription

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	Sim
userId	string	Não

Resposta

Retorna: UpdateSubscriptionAPIResponse

Exemplo

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

getTenantDailyUsages

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetTenantDailyUsagesOptions&	Sim

Resposta

Retorna: GetTenantDailyUsagesResponse

Exemplo

Exemplo getTenantDailyUsages

Copy

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

createTenantPackage

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
createTenantPackageBody	CreateTenantPackageBody	Sim

Resposta

Retorna: CreateTenantPackageResponse

Exemplo

createTenantPackage Exemplo

Copy

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

deleteTenantPackage

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Yes
id	string	Yes

Resposta

Retorna: APIEmptyResponse

Exemplo

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

getTenantPackage

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Resposta

Retorna: GetTenantPackageResponse

Exemplo

getTenantPackage Exemplo

Copy

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

getTenantPackages

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
skip	double	Não

Resposta

Retorna: GetTenantPackagesResponse

Exemplo

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

replaceTenantPackage

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
replaceTenantPackageBody	ReplaceTenantPackageBody	Sim

Resposta

Retorna: APIEmptyResponse

Exemplo

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

updateTenantPackage

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Yes
id	string	Yes
updateTenantPackageBody	UpdateTenantPackageBody	Yes

Resposta

Retorna: APIEmptyResponse

Exemplo

updateTenantPackage Exemplo

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();
            // tratamento de sucesso
        } catch (const std::exception& ex) {
            // tratamento de erro
        }
    });

createTenantUser

Parâmetros

Name	Type	Required	Description
tenantId	string	Yes
createTenantUserBody	CreateTenantUserBody	Yes

Resposta

Retorna: CreateTenantUserResponse

Exemplo

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

deleteTenantUser

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
options	const DeleteTenantUserOptions&	Sim

Resposta

Retorna: APIEmptyResponse

Exemplo

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

getTenantUser

Parameters

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Response

Retorna: GetTenantUserResponse

Example

Exemplo 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();
            // Use response as needed
        } catch (const std::exception&) {
            // Error handling
        }
    });

getTenantUsers

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
skip	double	Não

Resposta

Retorna: GetTenantUsersResponse

Exemplo

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

replaceTenantUser

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
replaceTenantUserBody	ReplaceTenantUserBody	Sim
updateComments	string	Não

Resposta

Retorna: APIEmptyResponse

Exemplo

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

sendLoginLink

Parameters

Nome	Tipo	Obrigatório
tenantId	string	Yes
id	string	Yes
redirectURL	string	No

Response

Retorna: APIEmptyResponse

Example

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

updateTenantUser

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
updateTenantUserBody	UpdateTenantUserBody	Sim
updateComments	string	Não

Resposta

Retorna: APIEmptyResponse

Exemplo

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

createTenant

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
createTenantBody	CreateTenantBody	Sim

Resposta

Retorna: CreateTenantResponse

Exemplo

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

deleteTenant

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
sure	string	Não

Resposta

Retorna: APIEmptyResponse

Exemplo

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

getTenant

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Resposta

Retorna: GetTenantResponse

Exemplo

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

getTenants

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetTenantsOptions&	Sim

Resposta

Retorna: GetTenantsResponse

Exemplo

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

updateTenant

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
updateTenantBody	UpdateTenantBody	Sim

Resposta

Retorna: APIEmptyResponse

Exemplo

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

changeTicketState

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
userId	string	Sim
id	string	Sim
changeTicketStateBody	ChangeTicketStateBody	Sim

Resposta

Retorna: ChangeTicketStateResponse

Exemplo

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

createTicket

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
userId	string	Sim
createTicketBody	CreateTicketBody	Sim

Resposta

Retorna: CreateTicketResponse

Exemplo

Exemplo 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();
        // Use a resposta conforme necessário
    }catch(const std::exception&){
        // Trate o erro
    }
});

getTicket

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
userId	string	Não

Resposta

Retorna: GetTicketResponse

Exemplo

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

getTickets

Parâmetros

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

Resposta

Retorna: GetTicketsResponse

Exemplo

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

getTranslations

Parâmetros

Nome	Tipo	Obrigatório
r_namespace	string	Sim
component	string	Sim
options	const GetTranslationsOptions&	Sim

Resposta

Retorna: GetTranslationsResponse

Exemplo

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

uploadImage

Upload and resize an image

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
file	HttpContent	Sim
options	const UploadImageOptions&	Sim

Resposta

Retorna: UploadImageResponse

Exemplo

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

getUserBadgeProgressById

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Resposta

Retorna: APIGetUserBadgeProgressResponse

Exemplo

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

getUserBadgeProgressByUserId

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
userId	string	Sim

Resposta

Retorna: APIGetUserBadgeProgressResponse

Exemplo

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

getUserBadgeProgressList

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetUserBadgeProgressListOptions&	Sim

Resposta

Retorna: APIGetUserBadgeProgressListResponse

Exemplo

getUserBadgeProgressList Exemplo

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

createUserBadge

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
createUserBadgeParams	CreateUserBadgeParams	Sim

Resposta

Retorna: APICreateUserBadgeResponse

Exemplo

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

deleteUserBadge

Parâmetros

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Resposta

Retorna: APIEmptySuccessResponse

Exemplo

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

getUserBadge

Parameters

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Response

Returns: APIGetUserBadgeResponse

Example

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

getUserBadges

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetUserBadgesOptions&	Sim

Resposta

Retorna: APIGetUserBadgesResponse

Exemplo

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

updateUserBadge

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
updateUserBadgeParams	UpdateUserBadgeParams	Sim

Resposta

Retorna: APIEmptySuccessResponse

Exemplo

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

getUserNotificationCount

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
sso	string	Não

Resposta

Retorna: GetUserNotificationCountResponse

Exemplo

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

getUserNotifications

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const GetUserNotificationsOptions&	Sim

Resposta

Retorna: GetMyNotificationsResponse

Exemplo

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

resetUserNotificationCount

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
sso	string	Não

Resposta

Retorna: ResetUserNotificationsResponse

Exemplo

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

resetUserNotifications

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
options	const ResetUserNotificationsOptions&	Sim

Resposta

Retorna: ResetUserNotificationsResponse

Exemplo

Exemplo 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) {
        // Processar resposta
    });

updateUserNotificationCommentSubscriptionStatus

Ativar ou desativar notificações para um comentário específico.

Parâmetros

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

Resposta

Retorna: UpdateUserNotificationCommentSubscriptionStatusResponse

Exemplo

updateUserNotificationCommentSubscriptionStatus Exemplo

Copy

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

updateUserNotificationPageSubscriptionStatus

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

Parameters

Nome	Tipo	Obrigatório
tenantId	string	Sim
urlId	string	Sim
url	string	Sim
pageTitle	string	Sim
subscribedOrUnsubscribed	string	Sim
sso	string	Não

Response

Retorna: UpdateUserNotificationPageSubscriptionStatusResponse

Exemplo

updateUserNotificationPageSubscriptionStatus Exemplo

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) {
        // processar resp se necessário
    });

updateUserNotificationStatus

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
notificationId	string	Sim
newStatus	string	Sim
sso	string	Não

Resposta

Retorna: UpdateUserNotificationStatusResponse

Exemplo

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

getUserPresenceStatuses

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
urlIdWS	string	Sim
userIds	string	Sim

Resposta

Retorna: GetUserPresenceStatusesResponse

Exemplo

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

searchUsers

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
urlId	string	Sim
options	const SearchUsersOptions&	Sim

Resposta

Retorna: SearchUsersResult

Exemplo

searchUsers Exemplo

Copy

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

getUser

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
id	string	Sim

Resposta

Retorna: GetUserResponse

Exemplo

Exemplo 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>();
            }
            // processe a resposta conforme necessário
        } catch (const std::exception&) {
            // tratar erro
        }
    });

createVote

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
commentId	string	Sim
direction	string	Sim
options	const CreateVoteOptions&	Sim

Resposta

Retorna: VoteResponse

Exemplo

createVote Exemplo

Copy

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

deleteVote

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
id	string	Sim
editKey	string	Não

Resposta

Retorna: VoteDeleteResponse

Exemplo

Exemplo 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();
        // Process response as needed
    } catch (const std::exception&) {
        // Handle error
    }
});

getVotes

Parâmetros

Nome	Tipo	Obrigatório	Descrição
tenantId	string	Sim
urlId	string	Sim

Resposta

Retorna: GetVotesResponse

Exemplo

Exemplo 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 (...) {
        // tratamento de erro
    }
});

getVotesForUser

Parâmetros

Nome	Tipo	Obrigatório
tenantId	string	Sim
urlId	string	Sim
options	const GetVotesForUserOptions&	Sim

Resposta

Retorna: GetVotesForUserResponse

Exemplo

Exemplo 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) {
        // handle response, e.g., iterate votes
    }
});

Precisa de ajuda?

Se você encontrar algum problema ou tiver dúvidas sobre o SDK C++, por favor:

Contribuindo

Contribuições são bem-vindas! Por favor, visite o repositório GitHub para obter as diretrizes de contribuição.

Idioma 🇧🇷 Português (Brasil)

Documentação

Primeiros passos

Referência da API

Uso

Agregação

Logs de Auditoria

Autenticação

Bloquear por comentário

Verificar Comentários Bloqueados

Comentários

Comentários para Usuário

Configurações de Domínio

Modelos de E-mail

Registro de Eventos

Publicações do Feed

Denunciar Comentário

GIFs

Hashtags

Moderação

Moderadores

Contagem de Notificações

Notificações

Reações da Página

Páginas

Eventos de Webhook Pendentes

Configurações de Perguntas

Resultados de Perguntas

Agregação de Resultados de Perguntas

Usuários SSO

Assinaturas

Uso Diário do Tenant

Pacotes do Tenant

Usuários do Tenant

Tenants

Tickets

Traduções

Enviar Imagem

Progresso de Insígnias do Usuário

Insígnias do Usuário

Notificações do Usuário

Status de Presença do Usuário

Busca de Usuários

Usuários

Votos

SDK C++ do FastComments

Repositório

Requisitos

Instalação

Instalar Dependências

Compilando a partir do Código-Fonte

Instalando

Conteúdo da Biblioteca

APIs Públicas vs Seguras

Início Rápido

Usando APIs Autenticadas (DefaultAPI)

Usando APIs Públicas (PublicAPI)

Usando APIs de Moderação (ModerationApi)

Problemas Comuns

Fazendo chamadas de API: Síncronas vs Assíncronas

Chamadas síncronas com .get()

Chamadas assíncronas com .then()

Escolhendo entre síncrono e assíncrono

Notas

IDs de Broadcast

SSO (Login Único)

Uso de SSO

SSO Simples

SSO Seguro

Documentação do fastcomments

Documentação para Endpoints da API

Documentação para Modelos

aggregate

Parameters

Response

Example

getAuditLogs

Parâmetros

Resposta

Exemplo

Chamadas síncronas com `.get()`

Chamadas assíncronas com `.then()`