SDK de FastComments en C++

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

SDK oficial en C++ para la API de FastComments

Repositorio

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

Realizar llamadas API: síncronas 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 de 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 de fastcomments

Documentación de los Endpoints de API

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

Clase	Método	Solicitud HTTP	Descripción
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	Agrupa documentos mediante su agrupación (si se proporciona groupBy) y aplica múltiples operaciones. Se admiten diferentes operaciones (p. ej., sum, countDistinct, avg, etc.).
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	Usuarios que comentaron anteriormente en la página que NO están actualmente en línea. Ordenados por displayName. Use esto después de agotar /users/online para renderizar una sección "Members". Paginación por cursor en commenterName: el servidor recorre el índice parcial {tenantId, urlId, commenterName} desde afterName hacia adelante mediante $gt, sin costo de $skip.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	Visitantes 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 la sala, incluidos espectadores anónimos que no enumeramos).
PublicApi	getPagesPublic	GET /pages/{tenantId}	Enumera las páginas de un tenant. Utilizado por el cliente de escritorio FChat para rellenar su lista de salas. Requiere que `enableFChat` sea true en la configuración personalizada resuelta de cada página. Las páginas que requieren SSO se filtran según el acceso grupal del usuario solicitante.
PublicApi	getTranslations	GET /translations/{namespace}/{component}
PublicApi	getUserNotificationCount	GET /user-notifications/get-count
PublicApi	getUserNotifications	GET /user-notifications
PublicApi	getUserPresenceStatuses	GET /user-presence-status
PublicApi	getUserReactsPublic	GET /feed-posts/{tenantId}/user-reacts
PublicApi	getUsersInfo	GET /pages/{tenantId}/users/info	Información a granel de usuarios para un tenant. Dado userIds, devuelve datos de visualización de User / SSOUser. Usado por el widget de comentarios para enriquecer a usuarios que acaban de aparecer mediante un evento de presencia. Sin contexto de página: la privacidad se aplica uniformemente (perfiles privados se ocultan).
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}	Activar o desactivar notificaciones para un comentario específico.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Activar o desactivar notificaciones para una página. Cuando los usuarios están suscritos a una página, se crean notificaciones para nuevos comentarios raíz, y también
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Subir y redimensionar una imagen
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Documentación de los Modelos

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

Obtener registros de auditoría

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

Cerrar sesión pública

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

Bloquear desde comentario (público)

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

Desbloquear comentario (público)

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

Comprobar comentarios bloqueados

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

Bloquear usuario por comentario

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

Crear comentario (público)

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

Eliminar comentario

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

Eliminar comentario (público)

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

Eliminar voto de comentario

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

Marcar comentario

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

Obtener comentario

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

Obtener comentarios

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

Obtener comentarios (públicos)

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

Obtener texto del comentario

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

Obtener nombres de usuarios que votaron el comentario

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

Bloquear comentario

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

Fijar comentario

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

Guardar comentario

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

Establecer texto del comentario

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

Desbloquear usuario por comentario

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

Desmarcar comentario

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

Desbloquear comentario

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

Desfijar comentario

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

Actualizar comentario

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

Votar comentario

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

Obtener comentarios del usuario

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

Agregar configuración de dominio

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

Eliminar configuración de dominio

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

Obtener configuración de dominio

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

Obtener configuraciones de dominio

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

Actualizar parcialmente configuración de dominio

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

Reemplazar configuración de dominio

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

Crear plantilla de correo

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

Eliminar plantilla de correo

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

Eliminar error de renderizado de plantilla de correo

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

Obtener plantilla de correo

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

Obtener definiciones de plantillas de correo

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

Obtener errores de renderizado de plantilla de correo

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

Obtener plantillas de correo

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

Renderizar plantilla de correo

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

Actualizar plantilla de correo

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

Obtener registro de eventos

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

Obtener registro global de eventos

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

Crear publicación del feed

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

Crear publicación del feed (pública)

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

Eliminar publicación del feed (pública)

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

Obtener publicaciones del feed

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

Obtener publicaciones del feed (públicas)

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

Obtener estadísticas de publicaciones del feed

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

Obtener reacciones de usuario (públicas)

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

Reaccionar a publicación del feed (pública)

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

Actualizar publicación del feed

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

Actualizar publicación del feed (pública)

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

Marcar comentario (público)

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

Obtener GIF grande

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

Buscar GIFs

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

GIFs en tendencia

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

Agregar hashtag

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

Agregar hashtags en masa

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

Eliminar hashtag

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

Obtener hashtags

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

Actualizar parcialmente hashtag

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

Eliminar voto de moderación

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

Obtener comentarios (API)

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

Obtener estado de exportación (API)

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

Obtener IDs (API)

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

Obtener usuarios baneados por comentario

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

Obtener estado de baneo del comentario

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

Obtener respuestas (hijos) del comentario

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

Obtener conteo

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

Obtener conteos

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

Obtener registros

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

Obtener insignias manuales

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

Obtener insignias manuales para el usuario

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

Obtener comentario de moderación

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

Obtener texto del comentario de moderación

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

Obtener resumen previo al baneo

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

Obtener resumen de búsqueda de comentarios

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

Buscar páginas

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

Buscar sitios

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

Obtener sugerencias de búsqueda

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

Buscar usuarios

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

Obtener factor de confianza

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

Obtener preferencia de baneo del usuario

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

Obtener perfil interno del usuario

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

Ajustar votos de comentario

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

Iniciar exportación (API)

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

Banear usuario por comentario

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

Deshacer baneo de usuario

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

Resumen previo al baneo en masa

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

Obtener comentarios por IDs

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

Reportar comentario

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

Eliminar comentario

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

Restaurar comentario eliminado

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

Establecer estado de aprobación del comentario

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

Establecer estado de revisión del comentario

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

Establecer estado de spam del comentario

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

Establecer texto del comentario

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

Quitar reporte del comentario

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

Enviar voto

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

Conceder insignia

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

Cerrar hilo

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

Quitar insignia

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

Reabrir hilo

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

Establecer factor de confianza

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

Crear moderador

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

Eliminar moderador

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

Obtener moderador

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

Obtener moderadores

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

Enviar invitación

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

Actualizar moderador

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

Eliminar conteo de notificaciones

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

Obtener conteo de notificaciones en caché

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

Obtener conteo de notificaciones

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

Obtener notificaciones

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

Actualizar notificación

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

Crear reacción de página V1

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

Crear reacción de página V2

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

Eliminar reacción de página V1

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

Eliminar reacción de página V2

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

Obtener me gusta de página V1

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

Obtener reacciones de página V2

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

Obtener usuarios que reaccionaron en página V2

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

Agregar página

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

Eliminar página

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

Obtener usuarios desconectados

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

Obtener usuarios conectados

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

Obtener página por URL/ID

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

Obtener páginas

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

Obtener páginas (públicas)

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

Obtener información de usuarios

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

Actualizar parcialmente página

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

Eliminar evento de webhook pendiente

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

Obtener conteo de eventos de webhook pendientes

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

Obtener eventos de webhook pendientes

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

Crear configuración de pregunta

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

Eliminar configuración de pregunta

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

Obtener configuración de pregunta

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

Obtener configuraciones de pregunta

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

Actualizar configuración de pregunta

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

Crear resultado de pregunta

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

Eliminar resultado de pregunta

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

Obtener resultado de pregunta

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

Obtener resultados de preguntas

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

Actualizar resultado de pregunta

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

Agregación de resultados de preguntas

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

Agregación masiva de resultados de preguntas

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

Combinar comentarios con resultados de preguntas

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

Agregar usuario SSO

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

Eliminar usuario SSO

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

Obtener usuario SSO por correo electrónico

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

Obtener usuario SSO por ID

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

Obtener usuarios SSO

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

Actualizar parcialmente usuario SSO

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

Reemplazar usuario SSO

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

Crear suscripción

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

Eliminar suscripción

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

Obtener suscripciones

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

Actualizar suscripción

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

Obtener usos diarios del inquilino

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

Crear paquete del inquilino

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

Eliminar paquete del inquilino

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

Obtener paquete del inquilino

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

Obtener paquetes del inquilino

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

Reemplazar paquete del inquilino

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

Actualizar paquete del inquilino

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

Crear usuario del inquilino

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

Eliminar usuario del inquilino

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

Obtener usuario del inquilino

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

Obtener usuarios del inquilino

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

Reemplazar usuario del inquilino

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

Enviar enlace de inicio de sesión

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

Actualizar usuario del inquilino

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

Crear inquilino

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

Eliminar inquilino

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

Obtener inquilino

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

Obtener inquilinos

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

Actualizar inquilino

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

Cambiar estado del ticket

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

Crear ticket

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

Obtener ticket

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

Obtener tickets

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

Obtener traducciones

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

Subir imagen

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

Obtener progreso de insignia por ID

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

Obtener progreso de insignia por ID de usuario

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

Obtener lista de progreso de insignias de usuario

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

Crear insignia de usuario

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

Eliminar insignia de usuario

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

Obtener insignia de usuario

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

Obtener insignias de usuario

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

Actualizar insignia de usuario

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

Obtener conteo de notificaciones del usuario

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

Obtener notificaciones del usuario

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

Restablecer conteo de notificaciones del usuario

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

Restablecer notificaciones del usuario

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

Actualizar estado de suscripción a comentarios del usuario

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

Actualizar estado de suscripción a páginas del usuario

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

Actualizar estado de notificación del usuario

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

Obtener estados de presencia de usuarios

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

Buscar usuarios

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

Obtener usuario

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

Crear voto

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

Eliminar voto

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

Obtener votos

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

Obtener votos del usuario

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

Primeros pasos

Referencia de API

Uso

Agregación

Registros de auditoría

Autenticación

Bloquear desde comentario

Comprobar comentarios bloqueados

Comentarios

Comentarios del usuario

Configuraciones de dominio

Plantillas de correo

Registro de eventos

Publicaciones del feed

Marcar comentario

GIFs

Hashtags

Moderación

Moderadores

Conteo de notificaciones

Notificaciones

Reacciones de página

Páginas

Eventos de webhook pendientes

Configuraciones de pregunta

Resultados de preguntas

Agregación de resultados de preguntas

Usuarios SSO

Suscripciones

Uso diario del inquilino

Paquetes del inquilino

Usuarios del inquilino

Inquilinos

Tickets

Traducciones

Subir imagen

Progreso de insignias de usuario

Insignias de usuario

Notificaciones de usuario

Estado de presencia de usuario

Búsqueda de usuarios

Usuarios

Votos

SDK de FastComments en C++

Repositorio

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

Realizar llamadas API: síncronas 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 de SSO

SSO simple

SSO seguro

Documentación de fastcomments

Documentación de los Endpoints de API

Documentación de los Modelos

Agregación

Parámetros

Respuesta

Ejemplo

Obtener registros de auditoría

Parameters

Response

Example

Llamadas sincrónicas con `.get()`

Llamadas asíncronas con `.then()`