FastComments SDK C++

Este es el SDK oficial en C++ para FastComments.

SDK oficial en C++ para la API de FastComments

Repositorio

Agentes de codificación IA

Proporcione a su agente de codificación el contexto de FastComments que necesita: widgets, configuración, Secure SSO, la API REST y los SDK:

npx skills add fastcomments/skills

Funciona con Claude Code, Codex, Cursor, Copilot, Gemini y cualquier otro agente que soporte el skills CLI.

Requisitos

C++17 o posterior
CMake 3.14 o posterior
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (descargado automáticamente para pruebas)

Instalación

Instalar dependencias

sudo apt install libcpprest-dev libboost-all-dev

Compilar desde el código fuente

mkdir build
cd build
cmake ..
make

Instalación

sudo make install

Contenido de la biblioteca

Esta biblioteca contiene el cliente API generado y las utilidades SSO para facilitar el trabajo con la API.

API Client Library Docs

APIs públicas vs seguras

Para el cliente API, existen tres clases, DefaultApi, PublicApi y ModerationApi. El DefaultApi contiene métodos que requieren su clave API, y el PublicApi contiene métodos que pueden ejecutarse directamente desde un navegador, dispositivo móvil, etc., sin autenticación. El ModerationApi ofrece un conjunto extenso de APIs de moderación en tiempo real y rápidas. Cada método del ModerationApi acepta un parámetro sso y puede autenticarse mediante SSO o una cookie de sesión de FastComments.com.

Inicio rápido

Usando APIs Autenticadas (DefaultAPI)

Importante:

Debes establecer la URL base (el generador cpp-restsdk no la lee del spec OpenAPI)
Debes establecer tu clave API en el ApiClient antes de hacer solicitudes autenticadas. Si no lo haces, las solicitudes fallarán con un error 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>();

    // REQUERIDO: Establecer la URL base (elige tu región)
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));  // US
    // O: config->setBaseUrl(utility::conversions::to_string_t("https://eu.fastcomments.com"));  // EU

    // REQUERIDO: Establecer tu clave API
    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);

    // Ahora realiza llamadas API autenticadas
    return 0;
}

Usando APIs Públicas (PublicAPI)

Los endpoints públicos no requieren autenticación:

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

    // REQUERIDO: Establecer la URL base
    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);

    // Realizar llamadas API públicas
    return 0;
}

Usando APIs de Moderación (ModerationApi)

El ModerationApi alimenta el panel de moderador. Cada método acepta un parámetro sso para que la llamada se ejecute en nombre de un moderador autenticado vía SSO (consulta la sección SSO a continuación para saber cómo crear un 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>();

    // REQUERIDO: Establecer la URL base
    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);

    // Pasar el token SSO del moderador para autenticar la llamada
    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 Comunes

"URI must contain a hostname" error: Asegúrate de llamar a config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) antes de crear el ApiClient. El generador cpp-restsdk no lee automáticamente la URL del servidor del spec OpenAPI.
401 "missing-api-key" error: Asegúrate de llamar a config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) antes de crear la instancia DefaultAPI.
Wrong API class: Usa DefaultApi para solicitudes autenticadas del lado del servidor, PublicApi para solicitudes del lado cliente/públicas, y ModerationApi para solicitudes del panel de moderador (autenticadas con un token SSO de moderador).

Realizando llamadas API: Sincrónicas vs Asíncronas

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

Llamadas sincrónicas con `.get()`

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

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

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

// Los parámetros requeridos son posicionales; los opcionales se colocan en la estructura de opciones
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();  // Bloquea hasta que la solicitud HTTP se complete

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

Llamadas asíncronas con `.then()`

Use .then() for non-blocking asynchronous execution with callbacks:

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

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

// Los parámetros requeridos son posicionales; los opcionales se colocan en la estructura de opciones
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) {
    // Esto se ejecuta de forma asíncrona cuando la solicitud se completa
    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; // La ejecución continúa inmediatamente sin bloqueo

Elegir entre síncrono y asíncrono

The choice depends on your runtime environment and application architecture:

.get() (Bloqueo síncrono)

Bloquea el hilo que realiza la llamada hasta que la solicitud HTTP se complete
Flujo de código más simple, más fácil de razonar
Adecuado para hilos de trabajo dedicados, procesamiento por lotes o herramientas de línea de comandos
No adecuado para bucles de eventos, hilos GUI o servidores monohilo

.then() (Asíncrono sin bloqueo)

Devuelve inmediatamente, el callback se ejecuta cuando la solicitud se completa
No bloquea el hilo que realiza la llamada
Requerido para arquitecturas dirigidas por eventos, aplicaciones GUI o bucles de eventos monohilo
Permite encadenar múltiples operaciones
Flujo de control más complejo

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

Notas

IDs de difusión

Verás que se supone que debes pasar un broadcastId en algunas llamadas de la API. Cuando recibas eventos, obtendrás este ID de vuelta, por lo que sabrás ignorar el evento si planeas aplicar cambios de forma optimista en el cliente (lo que probablemente querrás hacer, ya que ofrece la mejor experiencia). Pasa un UUID aquí. El ID debe ser lo suficientemente único para no ocurrir dos veces en una sesión del navegador.

SSO (Inicio de sesión único)

Para ejemplos de SSO, consulte más abajo.

Uso SSO

SSO simple

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

Documentación para fastcomments

Documentation for API Endpoints

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

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

Documentation for Models

Documentation for Authorization

api_key

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

agregación

Agrega documentos agrupándolos (si se proporciona groupBy) y aplicando múltiples operaciones. Se admiten diferentes operaciones (p. ej., sum, countDistinct, avg, etc.).

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
aggregationRequest	AggregationRequest	Sí
options	const AggregateOptions&	Sí

Respuesta

Returns: AggregateResponse

Ejemplo

Ejemplo de agregación

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();
            // procesar respuesta
        } catch (const std::exception& e) {
            // manejar error
        }
    });

getAuditLogs

Parameters

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const GetAuditLogsOptions&	Sí

Response

Devuelve: GetAuditLogsResponse

Example

Ejemplo 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 la respuesta
    } catch (const std::exception& e) {
        // manejar el error
    }
});

logoutPublic

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

logoutPublic Ejemplo

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

Name	Type	Required
tenantId	string	Sí
commentId	string	Sí
publicBlockFromCommentParams	PublicBlockFromCommentParams	Sí
sso	string	No

Respuesta

Devuelve: BlockSuccess

Ejemplo

blockFromCommentPublic Ejemplo

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

Nombre	Tipo	Obligatorio
tenantId	string	Yes
commentId	string	Yes
publicBlockFromCommentParams	PublicBlockFromCommentParams	Yes
sso	string	No

Respuesta

Devuelve: UnblockSuccess

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Sí
commentIds	string	Sí
sso	string	No

Respuesta

Devuelve: CheckBlockedCommentsResponse

Ejemplo

checkedCommentsForBlocked Ejemplo

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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
blockFromCommentParams	BlockFromCommentParams	Sí
options	const BlockUserFromCommentOptions&	Sí

Respuesta

Devuelve: BlockSuccess

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Sí
urlId	string	Sí
broadcastId	string	Sí
commentData	CommentData	Sí
options	const CreateCommentPublicOptions&	Sí

Respuesta

Devuelve: SaveCommentsResponseWithPresence

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Sí
id	string	Sí
options	const DeleteCommentOptions&	Sí

Respuesta

Devuelve: DeleteCommentResult

Ejemplo

Ejemplo 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

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
options	const DeleteCommentPublicOptions&	Yes

Respuesta

Devuelve: PublicAPIDeleteCommentResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Yes
commentId	string	Yes
voteId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
options	const DeleteCommentVoteOptions&	Yes

Respuesta

Devuelve: VoteDeleteResponse

Ejemplo

Ejemplo deleteCommentVote

Copy

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

flagComment

Parameters

Nombre	Tipo	Obligatorio
tenantId	string	Yes
id	string	Yes
options	const FlagCommentOptions&	Yes

Response

Devuelve: FlagCommentResponse

Example

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
id	string	Sí

Respuesta

Devuelve: APIGetCommentResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const GetCommentsOptions&	Sí

Respuesta

Devuelve: APIGetCommentsResponse

Ejemplo

Ejemplo 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();
        // usar la respuesta según sea necesario
    } catch (const std::exception& e) {
        // manejar el error
    }
});

getCommentsPublic

solicitud tenantId urlId

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
urlId	string	Sí
options	const GetCommentsPublicOptions&	Sí

Respuesta

Devuelve: GetCommentsResponseWithPresence_PublicComment_

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
commentId	string	Sí
options	const GetCommentTextOptions&	Sí

Respuesta

Devuelve: PublicAPIGetCommentTextResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
commentId	string	Sí
dir	int32_t	Sí
sso	string	No

Respuesta

Devuelve: GetCommentVoteUserNamesSuccessResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Requerido
tenantId	string	Sí
commentId	string	Sí
broadcastId	string	Sí
sso	string	No

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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

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

Respuesta

Devuelve: ChangeCommentPinStatusResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Yes
createCommentParams	CreateCommentParams	Yes
options	const SaveCommentOptions&	Yes

Respuesta

Devuelve: APISaveCommentResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Requerido
tenantId	string	Sí
commentId	string	Sí
broadcastId	string	Sí
commentTextUpdateRequest	CommentTextUpdateRequest	Sí
options	const SetCommentTextOptions&	Sí

Respuesta

Devuelve: PublicAPISetCommentTextResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
unBlockFromCommentParams	UnBlockFromCommentParams	Sí
options	const UnBlockUserFromCommentOptions&	Sí

Respuesta

Devuelve: UnblockSuccess

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
options	const UnFlagCommentOptions&	Sí

Respuesta

Devuelve: FlagCommentResponse

Ejemplo

unFlagComment Ejemplo

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;
            // procesar estado si es necesario
        }
    })
    .then([](pplx::task<void> previous) {
        try {
            previous.get();
        } catch (const std::exception& e) {
            // manejar error
        }
    });

unLockComment

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
commentId	string	Sí
broadcastId	string	Sí
sso	string	No

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Sí
commentId	string	Sí
broadcastId	string	Sí
sso	string	No

Respuesta

Devuelve: ChangeCommentPinStatusResponse

Ejemplo

Ejemplo 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

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
updatableCommentParams	UpdatableCommentParams	Sí
options	const UpdateCommentOptions&	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Yes
commentId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
voteBodyParams	VoteBodyParams	Yes
options	const VoteCommentOptions&	Yes

Respuesta

Devuelve: VoteResponse

Ejemplo

voteComment Ejemplo

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();
           // manejar la respuesta
       } catch (const std::exception&) {
       }
   });

getCommentsForUser

Parámetros

Nombre	Tipo	Requerido	Descripción
options	const GetCommentsForUserOptions&	Sí

Respuesta

Devuelve: GetCommentsForUserResponse

Ejemplo

Ejemplo getCommentsForUser

Copy

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

addDomainConfig

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
addDomainConfigParams	AddDomainConfigParams	Sí

Respuesta

Devuelve: AddDomainConfigResponse

Ejemplo

Ejemplo 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

Name	Type	Required	Description
tenantId	string	Sí
domain	string	Sí

Respuesta

Devuelve: DeleteDomainConfigResponse

Ejemplo

Ejemplo 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

Name	Type	Required	Description
tenantId	string	Sí
domain	string	Sí

Respuesta

Devuelve: GetDomainConfigResponse

Ejemplo

Ejemplo 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) {
            // manejar moderación habilitada
        }
        if (theme) {
            // usar el valor del tema
        }
    })
    .wait();

getDomainConfigs

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí

Respuesta

Devuelve: GetDomainConfigsResponse

Ejemplo

Ejemplo 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

Parameters

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

Response

Devuelve: PatchDomainConfigResponse

Example

Ejemplo 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) {
        // manejo de éxito
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* manejo de error */ }
    });

putDomainConfig

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
domainToUpdate	string	Sí
updateDomainConfigParams	UpdateDomainConfigParams	Sí

Respuesta

Devuelve: PutDomainConfigResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Yes
createEmailTemplateBody	CreateEmailTemplateBody	Yes

Respuesta

Devuelve: CreateEmailTemplateResponse

Ejemplo

createEmailTemplate Ejemplo

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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Yes
id	string	Yes

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

deleteEmailTemplate Ejemplo

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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
errorId	string	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo de deleteEmailTemplateRenderError

Copy

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

getEmailTemplate

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
id	string	Sí

Respuesta

Devuelve: GetEmailTemplateResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Yes

Respuesta

Devuelve: GetEmailTemplateDefinitionsResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
skip	double	No

Respuesta

Devuelve: GetEmailTemplateRenderErrorsResponse

Ejemplo

getEmailTemplateRenderErrors Ejemplo

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 la respuesta según sea necesario
        } catch (const std::exception& ex) {
            // Manejar el error
        }
    });

getEmailTemplates

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
skip	double	No

Respuesta

Devuelve: GetEmailTemplatesResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Sí
renderEmailTemplateBody	RenderEmailTemplateBody	Sí
locale	string	No

Respuesta

Devuelve: RenderEmailTemplateResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
updateEmailTemplateBody	UpdateEmailTemplateBody	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo de 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) {
        // manejo de éxito
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception &) { /* manejo de errores */ }
    });

getEventLog

req tenantId urlId userIdWS

Parámetros

Name	Type	Required
tenantId	string	Sí
urlId	string	Sí
userIdWS	string	Sí
startTime	int64_t	Sí
endTime	int64_t	No

Respuesta

Devuelve: GetEventLogResponse

Ejemplo

Ejemplo 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

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

Respuesta

Devuelve: GetEventLogResponse

Ejemplo

getGlobalEventLog Ejemplo

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

Nombre	Tipo	Requerido
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
options	const CreateFeedPostOptions&	Yes

Respuesta

Devuelve: CreateFeedPostsResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
options	const CreateFeedPostPublicOptions&	Yes

Respuesta

Devuelve: CreateFeedPostResponse

Ejemplo

Ejemplo 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

Name	Type	Required
tenantId	string	Yes
postId	string	Yes
options	const DeleteFeedPostPublicOptions&	Yes

Respuesta

Devuelve: DeleteFeedPostPublicResponse

Ejemplo

Ejemplo deleteFeedPostPublic

Copy

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

getFeedPosts

req tenantId afterId

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
options	const GetFeedPostsOptions&	Sí

Respuesta

Devuelve: GetFeedPostsResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const GetFeedPostsPublicOptions&	Sí

Respuesta

Devuelve: PublicFeedPostsResponse

Ejemplo

Ejemplo de 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);
        // Usar processed según sea necesario
    }catch(const std::exception&){
        // Manejar error
    }
});

getFeedPostsStats

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
postIds	vector<string	Sí
sso	string	No

Respuesta

Devuelve: FeedPostsStatsResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
options	const GetUserReactsPublicOptions&	Sí

Respuesta

Devuelve: UserReactsResponse

Ejemplo

getUserReactsPublic Ejemplo

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

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Yes
postId	string	Yes
reactBodyParams	ReactBodyParams	Yes
options	const ReactFeedPostPublicOptions&	Yes

Respuesta

Devuelve: ReactFeedPostResponse

Ejemplo

reactFeedPostPublic Ejemplo

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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
feedPost	FeedPost	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo updateFeedPost

Copy

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

updateFeedPostPublic

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Yes
postId	string	Yes
updateFeedPostParams	UpdateFeedPostParams	Yes
options	const UpdateFeedPostPublicOptions&	Yes

Respuesta

Devuelve: CreateFeedPostResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
commentId	string	Sí
isFlagged	bool	Sí
sso	string	No

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Yes
largeInternalURLSanitized	string	Yes

Respuesta

Devuelve: GifGetLargeResponse

Ejemplo

getGifLarge Ejemplo

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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
search	string	Sí
options	const GetGifsSearchOptions&	Sí

Respuesta

Devuelve: GetGifsSearchResponse

Ejemplo

Ejemplo getGifsSearch

Copy

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

getGifsTrending

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
options	const GetGifsTrendingOptions&	Sí

Respuesta

Devuelve: GetGifsTrendingResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
createHashTagBody	CreateHashTagBody	Sí

Respuesta

Retorna: CreateHashTagResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Sí

Respuesta

Devuelve: BulkCreateHashTagsResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Yes
tag	string	Yes
deleteHashTagRequestBody	DeleteHashTagRequestBody	Yes

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo deleteHashTag

Copy

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

getHashTags

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
page	double	No

Respuesta

Devuelve: GetHashTagsResponse

Ejemplo

Ejemplo de 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 la respuesta
    } catch (const std::exception&) {
        // manejar el error
    }
});

patchHashTag

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
tag	string	Sí
updateHashTagBody	UpdateHashTagBody	Sí

Respuesta

Devuelve: UpdateHashTagResponse

Ejemplo

Ejemplo patchHashTag

Copy

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

deleteModerationVote

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
commentId	string	Sí
voteId	string	Sí
options	const DeleteModerationVoteOptions&	Sí

Respuesta

Devuelve: VoteDeleteResponse

Ejemplo

Ejemplo de 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

Parameters

Name	Type	Required	Description
tenantId	string	Sí
options	const GetApiCommentsOptions&	Sí

Response

Devuelve: ModerationAPIGetCommentsResponse

Example

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const GetApiExportStatusOptions&	Sí

Respuesta

Devuelve: ModerationExportStatusResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const GetApiIdsOptions&	Sí

Respuesta

Devuelve: ModerationAPIGetCommentIdsResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Sí
commentId	string	Sí
sso	string	No

Respuesta

Devuelve: GetBannedUsersFromCommentResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
commentId	string	Sí
sso	string	No

Respuesta

Devuelve: GetCommentBanStatusResponse

Ejemplo

getCommentBanStatus Ejemplo

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

Nombre	Tipo	Requerido
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Respuesta

Devuelve: ModerationAPIChildCommentsResponse

Ejemplo

Ejemplo de 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	Sí
options	const GetCountOptions&	Sí

Respuesta

Devuelve: ModerationAPICountCommentsResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
sso	string	No

Respuesta

Devuelve: GetBannedUsersCountResponse

Ejemplo

Ejemplo 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

Name	Type	Required
tenantId	string	Sí
commentId	string	Sí
sso	string	No

Respuesta

Devuelve: ModerationAPIGetLogsResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Yes
sso	string	No

Respuesta

Devuelve: GetTenantManualBadgesResponse

Ejemplo

Ejemplo 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();
            // procesar la respuesta, por ejemplo, response->badgeList
        } catch (const std::exception& ex) {
            // manejar error
        }
    });

getManualBadgesForUser

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const GetManualBadgesForUserOptions&	Sí

Respuesta

Devuelve: GetUserManualBadgesResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Requerido
tenantId	string	Sí
commentId	string	Sí
options	const GetModerationCommentOptions&	Sí

Respuesta

Retorna: ModerationAPICommentResponse

Ejemplo

Ejemplo 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();
            // Procesar la respuesta según sea necesario
        } catch (const std::exception& ex) {
            // Manejar el error
        }
    });

getModerationCommentText

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Respuesta

Devuelve: GetCommentTextResponse

Ejemplo

getModerationCommentText Ejemplo

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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
commentId	string	Sí
options	const GetPreBanSummaryOptions&	Sí

Respuesta

Devuelve: PreBanSummary

Ejemplo

Ejemplo 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();
            // procesar el resumen
        } catch (const std::exception&) {
            // manejar el error
        }
    });

getSearchCommentsSummary

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const GetSearchCommentsSummaryOptions&	Sí

Respuesta

Devuelve: ModerationCommentSearchResponse

Ejemplo

Ejemplo 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

Parameters

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

Response

Returns: ModerationPageSearchResponse

Example

Ejemplo 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 la respuesta
        } catch (const std::exception& e) {
            // manejar el error
        }
    });

getSearchSites

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const GetSearchSitesOptions&	Sí

Respuesta

Devuelve: ModerationSiteSearchResponse

Ejemplo

Ejemplo 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 procesamiento
           }
       } catch (const std::exception&) {
           // manejo de errores
       }
   });

getSearchSuggest

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const GetSearchSuggestOptions&	Sí

Respuesta

Devuelve: ModerationSuggestResponse

Ejemplo

Ejemplo getSearchSuggest

Copy

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

getSearchUsers

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Yes
options	const GetSearchUsersOptions&	Yes

Respuesta

Devuelve: ModerationUserSearchResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const GetTrustFactorOptions&	Sí

Respuesta

Devuelve: GetUserTrustFactorResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
sso	string	No

Respuesta

Devuelve: APIModerateGetUserBanPreferencesResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const GetUserInternalProfileOptions&	Sí

Respuesta

Devuelve: GetUserInternalProfileResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Yes
commentId	string	Yes
adjustCommentVotesParams	AdjustCommentVotesParams	Yes
options	const PostAdjustCommentVotesOptions&	Yes

Respuesta

Devuelve: AdjustVotesResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
options	const PostApiExportOptions&	Sí

Respuesta

Devuelve: ModerationExportResponse

Ejemplo

Ejemplo postApiExport

Copy

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

postBanUserFromComment

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Yes
commentId	string	Yes
options	const PostBanUserFromCommentOptions&	Yes

Respuesta

Devuelve: BanUserFromCommentResult

Ejemplo

postBanUserFromComment Ejemplo

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

postBanUserUndo

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Yes
banUserUndoParams	BanUserUndoParams	Yes
sso	string	No

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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){
    // manejar el éxito
});

postBulkPreBanSummary

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Yes
bulkPreBanParams	BulkPreBanParams	Yes
options	const PostBulkPreBanSummaryOptions&	Yes

Respuesta

Devuelve: BulkPreBanSummary

Ejemplo

postBulkPreBanSummary Ejemplo

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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
commentsByIdsParams	CommentsByIdsParams	Sí
sso	string	No

Respuesta

Devuelve: ModerationAPIChildCommentsResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
commentId	string	Sí
options	const PostFlagCommentOptions&	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Obligatorio
tenantId	string	Yes
commentId	string	Yes
options	const PostRemoveCommentOptions&	Yes

Respuesta

Devuelve: PostRemoveCommentApiResponse

Ejemplo

postRemoveComment Ejemplo

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();
            // Procesar la respuesta
        } catch (const std::exception& ex) {
            // Manejar el error
        }
    });

postRestoreDeletedComment

Parameters

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

Response

Devuelve: APIEmptyResponse

Example

postRestoreDeletedComment Ejemplo

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

Nombre	Tipo	Requerido
tenantId	string	Sí
commentId	string	Sí
options	const PostSetCommentApprovalStatusOptions&	Sí

Respuesta

Devuelve: SetCommentApprovedResponse

Ejemplo

postSetCommentApprovalStatus Ejemplo

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

Nombre	Tipo	Requerido
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentReviewStatusOptions&	Yes

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo de postSetCommentReviewStatus

Copy

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

postSetCommentSpamStatus

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
commentId	string	Sí
options	const PostSetCommentSpamStatusOptions&	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo postSetCommentSpamStatus

Copy

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

postSetCommentText

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
commentId	string	Sí
setCommentTextParams	SetCommentTextParams	Sí
options	const PostSetCommentTextOptions&	Sí

Respuesta

Devuelve: SetCommentTextResponse

Ejemplo

Ejemplo postSetCommentText

Copy

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

postUnFlagComment

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
commentId	string	Sí
options	const PostUnFlagCommentOptions&	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo postUnFlagComment

Copy

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

postVote

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Yes
commentId	string	Yes
options	const PostVoteOptions&	Yes

Respuesta

Devuelve: VoteResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Yes
badgeId	string	Yes
options	const PutAwardBadgeOptions&	Yes

Respuesta

Devuelve: AwardUserBadgeResponse

Ejemplo

putAwardBadge Ejemplo

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

Nombre	Tipo	Requerido
tenantId	string	Yes
urlId	string	Yes
sso	string	No

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Yes
badgeId	string	Yes
options	const PutRemoveBadgeOptions&	Yes

Respuesta

Devuelve: RemoveUserBadgeResponse

Ejemplo

Ejemplo putRemoveBadge

Copy

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

putReopenThread

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
urlId	string	Sí
sso	string	No

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const SetTrustFactorOptions&	Sí

Respuesta

Devuelve: SetUserTrustFactorResponse

Ejemplo

Ejemplo setTrustFactor

Copy

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

createModerator

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
createModeratorBody	CreateModeratorBody	Sí

Respuesta

Devuelve: CreateModeratorResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
sendEmail	string	No

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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) {
        // manejar éxito
    });

getModerator

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
id	string	Sí

Respuesta

Devuelve: GetModeratorResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
skip	double	No

Respuesta

Devuelve: GetModeratorsResponse

Ejemplo

getModerators Ejemplo

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

Nombre	Tipo	Requerido
tenantId	string	Sí
id	string	Sí
fromName	string	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo sendInvite

Copy

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

updateModerator

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
updateModeratorBody	UpdateModeratorBody	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo de 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

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
id	string	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
id	string	Sí

Respuesta

Devuelve: GetCachedNotificationCountResponse

Ejemplo

Ejemplo 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();
            // procesar respuesta
        } catch (const std::exception&) {
            // manejar error
        }
    });

getNotificationCount

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const GetNotificationCountOptions&	Sí

Respuesta

Devuelve: GetNotificationCountResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const GetNotificationsOptions&	Sí

Respuesta

Devuelve: GetNotificationsResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Obligatorio
tenantId	string	Yes
id	string	Yes
updateNotificationBody	UpdateNotificationBody	Yes
userId	string	No

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
urlId	string	Sí
title	string	No

Respuesta

Devuelve: CreateV1PageReact

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Sí
urlId	string	Sí
id	string	Sí
title	string	No

Respuesta

Devuelve: CreateV1PageReact

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
urlId	string	Sí

Respuesta

Devuelve: CreateV1PageReact

Ejemplo

Ejemplo deleteV1PageReact

Copy

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

deleteV2PageReact

Parameters

Nombre	Tipo	Obligatorio
tenantId	string	Yes
urlId	string	Yes
id	string	Yes

Response

Devuelve: CreateV1PageReact

Example

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Yes
urlId	string	Yes

Respuesta

Devuelve: GetV1PageLikes

Ejemplo

Ejemplo getV1PageLikes

Copy

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

getV2PageReacts

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
urlId	string	Sí

Respuesta

Devuelve: GetV2PageReacts

Ejemplo

Ejemplo getV2PageReacts

Copy

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

getV2PageReactUsers

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
urlId	string	Sí
id	string	Sí

Respuesta

Devuelve: GetV2PageReactUsersResponse

Ejemplo

Ejemplo 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();
        // Utilice la respuesta según sea necesario
    }catch(const std::exception&){
        // Manejar el error
    }
});

addPage

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
createAPIPageData	CreateAPIPageData	Sí

Respuesta

Devuelve: AddPageAPIResponse

Ejemplo

addPage Ejemplo

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) {
            // manejar la adición exitosa
        } else {
            // manejar error
        }
    });

deletePage

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
id	string	Sí

Respuesta

Devuelve: DeletePageAPIResponse

Ejemplo

Ejemplo 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();
           // procesar la respuesta según sea necesario
       } catch (const std::exception& ex) {
           // manejar el error
       }
   });

getOfflineUsers

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

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
urlId	string	Sí
options	const GetOfflineUsersOptions&	Sí

Respuesta

Devuelve: PageUsersOfflineResponse

Ejemplo

Ejemplo 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

Vistas actualmente en línea de una página: personas cuya sesión de websocket está suscrita a la página en este momento.
Devuelve anonCount + totalCount (suscriptores de toda la sala, incluidos los espectadores anónimos que no enumeramos).

Parámetros

Name	Type	Required
tenantId	string	Sí
urlId	string	Sí
options	const GetOnlineUsersOptions&	Sí

Respuesta

Devuelve: PageUsersOnlineResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
urlId	string	Sí

Respuesta

Devuelve: GetPageByURLIdAPIResponse

Ejemplo

Ejemplo 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

Parameters

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Yes

Respuesta

Devuelve: GetPagesAPIResponse

Ejemplo

Ejemplo 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.
Requires enableFChat to be true on the resolved custom config for each page.
Pages that require SSO are filtered against the requesting user's group access.

Parameters

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

Response

Returns: GetPublicPagesResponse

Example

Ejemplo 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();
        // procesar la respuesta si es necesario
    }catch(const std::exception&){
        // manejar el error si es necesario
    }
});

getUsersInfo

Información de usuarios en bloque para un inquilino. Dado userIds, devuelve información de visualización de User / SSOUser.
Usado por el widget de comentarios para enriquecer a los usuarios que acaban de aparecer mediante un evento de presencia.
Sin contexto de página: la privacidad se aplica de manera uniforme (los perfiles privados están enmascarados).

Parameters

Name	Type	Required	Description
tenantId	string	Sí
ids	string	Sí

Response

Devuelve: PageUsersInfoResponse

Example

getUsersInfo Ejemplo

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();
        // procesar respuesta
    }catch(const std::exception&){
        // manejar error
    }
});

patchPage

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
updateAPIPageData	UpdateAPIPageData	Sí

Respuesta

Devuelve: PatchPageAPIResponse

Ejemplo

patchPage Ejemplo

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) {
            // manejar el éxito
        }
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

deletePendingWebhookEvent

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
id	string	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

deletePendingWebhookEvent Ejemplo

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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
options	const GetPendingWebhookEventCountOptions&	Sí

Respuesta

Devuelve: GetPendingWebhookEventCountResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const GetPendingWebhookEventsOptions&	Sí

Respuesta

Devuelve: GetPendingWebhookEventsResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Yes
createQuestionConfigBody	CreateQuestionConfigBody	Yes

Respuesta

Devuelve: CreateQuestionConfigResponse

Ejemplo

Ejemplo 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

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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) {
        // manejar eliminación exitosa
    })
    .then([](pplx::task<void> t) {
        try {
            t.get();
        } catch (const std::exception&) {
            // manejar error
        }
    });

getQuestionConfig

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetQuestionConfigResponse

Example

Ejemplo 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();
            // Utilizar la respuesta según sea necesario
        } catch (const std::exception&) {
            // Manejar el error
        }
    });

getQuestionConfigs

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
skip	double	No

Respuesta

Devuelve: GetQuestionConfigsResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
updateQuestionConfigBody	UpdateQuestionConfigBody	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
createQuestionResultBody	CreateQuestionResultBody	Sí

Respuesta

Devuelve: CreateQuestionResultResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
id	string	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

deleteQuestionResult Ejemplo

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();
                // success handling
            }
            catch ( const std::exception& e )
            {
                // error handling
            }
        } );
}

getQuestionResult

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
id	string	Sí

Respuesta

Devuelve: GetQuestionResultResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const GetQuestionResultsOptions&	Sí

Respuesta

Devuelve: GetQuestionResultsResponse

Ejemplo

getQuestionResults Ejemplo

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();
        // manejar la respuesta
    });

updateQuestionResult

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
updateQuestionResultBody	UpdateQuestionResultBody	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const AggregateQuestionResultsOptions&	Sí

Respuesta

Devuelve: AggregateQuestionResultsResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Sí
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Sí
forceRecalculate	bool	No

Respuesta

Devuelve: BulkAggregateQuestionResultsResponse

Ejemplo

Ejemplo bulkAggregateQuestionResults

Copy

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

combineCommentsWithQuestionResults

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
options	const CombineCommentsWithQuestionResultsOptions&	Sí

Respuesta

Devuelve: CombineQuestionResultsWithCommentsResponse

Ejemplo

Ejemplo de 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);
            // Usa combined según sea necesario
        }catch(const std::exception&){
        }
    });

addSSOUser

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Yes
createAPISSOUserData	CreateAPISSOUserData	Yes

Respuesta

Devuelve: AddSSOUserAPIResponse

Ejemplo

Ejemplo addSSOUser

Copy

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

deleteSSOUser

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Yes
id	string	Yes
options	const DeleteSSOUserOptions&	Yes

Respuesta

Devuelve: DeleteSSOUserAPIResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Yes
email	string	Yes

Respuesta

Devuelve: GetSSOUserByEmailAPIResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
id	string	Sí

Respuesta

Devuelve: GetSSOUserByIdAPIResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
skip	int32_t	No

Respuesta

Devuelve: GetSSOUsersResponse

Ejemplo

Ejemplo 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

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

Respuesta

Devuelve: PatchSSOUserAPIResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
updateAPISSOUserData	UpdateAPISSOUserData	Sí
updateComments	bool	No

Respuesta

Devuelve: PutSSOUserAPIResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Sí

Respuesta

Devuelve: CreateSubscriptionAPIResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Yes
id	string	Yes
userId	string	No

Respuesta

Devuelve: DeleteSubscriptionAPIResponse

Ejemplo

deleteSubscription Ejemplo

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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
userId	string	No

Respuesta

Devuelve: GetSubscriptionsAPIResponse

Ejemplo

Ejemplo 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();
            // procesar respuesta
        } catch (const std::exception& e) {
            // manejar error
        }
    }
);

updateSubscription

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
id	string	Sí
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	Sí
userId	string	No

Respuesta

Devuelve: UpdateSubscriptionAPIResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
options	const GetTenantDailyUsagesOptions&	Sí

Respuesta

Devuelve: GetTenantDailyUsagesResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
createTenantPackageBody	CreateTenantPackageBody	Sí

Respuesta

Devuelve: CreateTenantPackageResponse

Ejemplo

createTenantPackage Ejemplo

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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
id	string	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Yes
id	string	Yes

Respuesta

Devuelve: GetTenantPackageResponse

Ejemplo

Ejemplo getTenantPackage

Copy

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

getTenantPackages

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
skip	double	No

Respuesta

Devuelve: GetTenantPackagesResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
replaceTenantPackageBody	ReplaceTenantPackageBody	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Requerido
tenantId	string	Sí
id	string	Sí
updateTenantPackageBody	UpdateTenantPackageBody	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo de updateTenantPackage

Copy

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

createTenantUser

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
createTenantUserBody	CreateTenantUserBody	Sí

Respuesta

Devuelve: CreateTenantUserResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Sí
id	string	Sí
options	const DeleteTenantUserOptions&	Sí

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
id	string	Sí

Respuesta

Devuelve: GetTenantUserResponse

Ejemplo

Ejemplo 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();
            // Usar la respuesta según sea necesario
        } catch (const std::exception&) {
            // Manejo de errores
        }
    });

getTenantUsers

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
skip	double	No

Respuesta

Devuelve: GetTenantUsersResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Yes
id	string	Yes
replaceTenantUserBody	ReplaceTenantUserBody	Yes
updateComments	string	No

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
id	string	Sí
redirectURL	string	No

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Yes
id	string	Yes
updateTenantUserBody	UpdateTenantUserBody	Yes
updateComments	string	No

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

updateTenantUser Ejemplo

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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
createTenantBody	CreateTenantBody	Sí

Respuesta

Devuelve: CreateTenantResponse

Ejemplo

createTenant Ejemplo

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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
sure	string	No

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
id	string	Sí

Respuesta

Devuelve: GetTenantResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
options	const GetTenantsOptions&	Sí

Respuesta

Devuelve: GetTenantsResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Yes
id	string	Yes
updateTenantBody	UpdateTenantBody	Yes

Respuesta

Devuelve: APIEmptyResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
userId	string	Sí
id	string	Sí
changeTicketStateBody	ChangeTicketStateBody	Sí

Respuesta

Devuelve: ChangeTicketStateResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Sí
userId	string	Sí
createTicketBody	CreateTicketBody	Sí

Respuesta

Devuelve: CreateTicketResponse

Ejemplo

Ejemplo 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();
        // Usar la respuesta según sea necesario
    }catch(const std::exception&){
        // Manejar el error
    }
});

getTicket

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
userId	string	No

Respuesta

Devuelve: GetTicketResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
options	const GetTicketsOptions&	Sí

Respuesta

Devuelve: GetTicketsResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
r_namespace	string	Yes
component	string	Yes
options	const GetTranslationsOptions&	Yes

Respuesta

Devuelve: GetTranslationsResponse

Ejemplo

Ejemplo de 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

Cargar y redimensionar una imagen

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
file	HttpContent	Sí
options	const UploadImageOptions&	Sí

Respuesta

Devuelve: UploadImageResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Yes
id	string	Yes

Respuesta

Devuelve: APIGetUserBadgeProgressResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
userId	string	Sí

Respuesta

Devuelve: APIGetUserBadgeProgressResponse

Ejemplo

getUserBadgeProgressByUserId Ejemplo

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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
options	const GetUserBadgeProgressListOptions&	Sí

Respuesta

Devuelve: APIGetUserBadgeProgressListResponse

Ejemplo

getUserBadgeProgressList Ejemplo

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

createUserBadge

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
createUserBadgeParams	CreateUserBadgeParams	Sí

Respuesta

Devuelve: APICreateUserBadgeResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Yes
id	string	Yes

Respuesta

Devuelve: APIEmptySuccessResponse

Ejemplo

deleteUserBadge Ejemplo

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

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
id	string	Sí

Respuesta

Devuelve: APIGetUserBadgeResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
options	const GetUserBadgesOptions&	Sí

Respuesta

Devuelve: APIGetUserBadgesResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido
tenantId	string	Yes
id	string	Yes
updateUserBadgeParams	UpdateUserBadgeParams	Yes

Respuesta

Devuelve: APIEmptySuccessResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
sso	string	No

Respuesta

Devuelve: GetUserNotificationCountResponse

Ejemplo

Ejemplo de 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();
        // usar resp según sea necesario
    }catch(const std::exception&){
        // manejar error
    }
});

getUserNotifications

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Yes
options	const GetUserNotificationsOptions&	Yes

Respuesta

Devuelve: GetMyNotificationsResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
sso	string	No

Respuesta

Devuelve: ResetUserNotificationsResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
options	const ResetUserNotificationsOptions&	Sí

Respuesta

Devuelve: ResetUserNotificationsResponse

Ejemplo

Ejemplo de 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) {
        // Procesar respuesta
    });

updateUserNotificationCommentSubscriptionStatus

Habilitar o deshabilitar notificaciones para un comentario específico.

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
notificationId	string	Sí
optedInOrOut	string	Sí
commentId	string	Sí
sso	string	No

Respuesta

Devuelve: UpdateUserNotificationCommentSubscriptionStatusResponse

Ejemplo

Ejemplo de updateUserNotificationCommentSubscriptionStatus

Copy

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

updateUserNotificationPageSubscriptionStatus

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

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Yes
urlId	string	Yes
url	string	Yes
pageTitle	string	Yes
subscribedOrUnsubscribed	string	Yes
sso	string	No

Respuesta

Devuelve: UpdateUserNotificationPageSubscriptionStatusResponse

Ejemplo

updateUserNotificationPageSubscriptionStatus Ejemplo

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) {
        // procesar resp si es necesario
    });

updateUserNotificationStatus

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
notificationId	string	Sí
newStatus	string	Sí
sso	string	No

Respuesta

Devuelve: UpdateUserNotificationStatusResponse

Ejemplo

Ejemplo de 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

Nombre	Tipo	Obligatorio
tenantId	string	Yes
urlIdWS	string	Yes
userIds	string	Yes

Respuesta

Devuelve: GetUserPresenceStatusesResponse

Ejemplo

Ejemplo 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

Nombre	Tipo	Obligatorio
tenantId	string	Sí
urlId	string	Sí
options	const SearchUsersOptions&	Sí

Respuesta

Devuelve: SearchUsersResult

Ejemplo

Ejemplo de searchUsers

Copy

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

getUser

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Yes
id	string	Yes

Respuesta

Devuelve: GetUserResponse

Ejemplo

Ejemplo 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>();
            }
            // procesar la respuesta según sea necesario
        } catch (const std::exception&) {
            // manejar el error
        }
    });

createVote

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Yes
commentId	string	Yes
direction	string	Yes
options	const CreateVoteOptions&	Yes

Respuesta

Devuelve: VoteResponse

Ejemplo

Ejemplo createVote

Copy

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

deleteVote

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
editKey	string	No

Respuesta

Devuelve: VoteDeleteResponse

Ejemplo

Ejemplo 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();
        // Procesar la respuesta según sea necesario
    } catch (const std::exception&) {
        // Manejar el error
    }
});

getVotes

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí
urlId	string	Sí

Respuesta

Devuelve: GetVotesResponse

Ejemplo

Ejemplo 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 (...) {
        // manejo de errores
    }
});

getVotesForUser

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
urlId	string	Sí
options	const GetVotesForUserOptions&	Sí

Respuesta

Returns: GetVotesForUserResponse

Ejemplo

getVotesForUser Ejemplo

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

¿Necesita ayuda?

Si encuentra algún problema o tiene preguntas sobre el SDK de C++, por favor:

Contribuir

¡Se aceptan contribuciones! Por favor visite el repositorio de GitHub para las directrices de contribución.

Idioma 🇪🇸 Español

Documentación

Comenzando

Referencia API

Uso

Agregación

Registros de auditoría

Autenticación

Bloquear desde comentario

Verificar comentarios bloqueados

Comentarios

Comentarios para usuario

Configuraciones de dominio

Plantillas de correo

Registro de eventos

Publicaciones de feed

Denunciar comentario

GIFs

Etiquetas

Moderación

Moderadores

Recuento de notificaciones

Notificaciones

Reacciones de página

Páginas

Eventos webhook pendientes

Configuraciones de preguntas

Resultados de preguntas

Agregación de resultados de preguntas

Usuarios SSO

Suscripciones

Uso diario del inquilino

Paquetes de inquilino

Usuarios del inquilino

Inquilinos

Tickets

Traducciones

Subir imagen

Progreso de insignias de usuario

Insignias de usuario

Notificaciones de usuario

Estado de presencia del usuario

Búsqueda de usuarios

Usuarios

Votos

FastComments SDK C++

Repositorio

Agentes de codificación IA

Requisitos

Instalación

Instalar dependencias

Compilar desde el código fuente

Instalación

Contenido de la biblioteca

APIs públicas vs seguras

Inicio rápido

Usando APIs Autenticadas (DefaultAPI)

Usando APIs Públicas (PublicAPI)

Usando APIs de Moderación (ModerationApi)

Problemas Comunes

Realizando llamadas API: Sincrónicas vs Asíncronas

Llamadas sincrónicas con .get()

Llamadas asíncronas con .then()

Elegir entre síncrono y asíncrono

Notas

IDs de difusión

SSO (Inicio de sesión único)

Uso SSO

SSO simple

SSO seguro

Documentación para fastcomments

Documentation for API Endpoints

Documentation for Models

Documentation for Authorization

api_key

agregación

Parámetros

Respuesta

Ejemplo

getAuditLogs

Llamadas sincrónicas con `.get()`

Llamadas asíncronas con `.then()`