SDK de FastComments para 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 de API generado y las utilidades SSO para facilitar el trabajo con la API.

API Client Library Docs

APIs públicas frente a protegidas

Para el cliente de API, hay dos clases, DefaultAPI y PublicAPI. DefaultAPI contiene métodos que requieren su clave de la API, y PublicAPI contiene llamadas a la API que pueden realizarse directamente desde un navegador/dispositivo móvil/etc. sin autenticación.

Inicio rápido

Uso de APIs autenticadas (DefaultAPI)

Importante:

Debes establecer la URL base (el generador cpp-restsdk no la lee desde la OpenAPI spec)
Debes establecer tu clave de 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: Establece 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: Establece tu clave de 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 a la API autenticadas
    return 0;
}

Uso de 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: Establece 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);

    // Realiza llamadas a la API públicas
    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 cpp-restsdk generator no lee automáticamente la URL del servidor desde la OpenAPI spec.
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 de DefaultAPI.
Wrong API class: Usa DefaultAPI para solicitudes autenticadas del lado del servidor, y PublicAPI para solicitudes del lado del cliente/públicas.

Realizar llamadas a la API: Sincrónicas vs Asíncronas

Todos los métodos de la API en este SDK devuelven pplx::task<std::shared_ptr<ResponseType>> del C++ REST SDK. Esto le da flexibilidad en cómo maneja las respuestas de la API.

Synchronous Calls with `.get()`

Use .get() para bloquear el hilo que realiza la llamada hasta que la solicitud se complete y recuperar el resultado de forma sincrónica:

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

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

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

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

Asynchronous Calls with `.then()`

Use .then() para ejecución asíncrona no bloqueante con callbacks:

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

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

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

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

Choosing Between Synchronous and Asynchronous

La elección depende de su entorno de ejecución y de la arquitectura de la aplicación:

.get() (Synchronous blocking)

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

.then() (Asynchronous non-blocking)

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

El conjunto de pruebas del SDK usa .get() exclusivamente, pero esto es apropiado para el entorno de pruebas donde el bloqueo es aceptable.

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 la API

Todas las URIs son relativas a 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	Agrega documentos agrupándolos (si se proporciona groupBy) y aplicando varias operaciones. Se soportan diferentes operaciones (por ejemplo, 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}
PublicApi	blockFromCommentPublic	POST /block-from-comment/{commentId}
PublicApi	checkedCommentsForBlocked	GET /check-blocked-comments
PublicApi	createCommentPublic	POST /comments/{tenantId}
PublicApi	createFeedPostPublic	POST /feed-posts/{tenantId}
PublicApi	deleteCommentPublic	DELETE /comments/{tenantId}/{commentId}
PublicApi	deleteCommentVote	DELETE /comments/{tenantId}/{commentId}/vote/{voteId}
PublicApi	deleteFeedPostPublic	DELETE /feed-posts/{tenantId}/{postId}
PublicApi	flagCommentPublic	POST /flag-comment/{commentId}
PublicApi	getCommentText	GET /comments/{tenantId}/{commentId}/text
PublicApi	getCommentVoteUserNames	GET /comments/{tenantId}/{commentId}/votes
PublicApi	getCommentsPublic	GET /comments/{tenantId}	req tenantId urlId
PublicApi	getEventLog	GET /event-log/{tenantId}	req tenantId urlId userIdWS
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	req tenantId afterId
PublicApi	getFeedPostsStats	GET /feed-posts/{tenantId}/stats
PublicApi	getGlobalEventLog	GET /event-log/global/{tenantId}	req tenantId urlId userIdWS
PublicApi	getUserNotificationCount	GET /user-notifications/get-count
PublicApi	getUserNotifications	GET /user-notifications
PublicApi	getUserPresenceStatuses	GET /user-presence-status
PublicApi	getUserReactsPublic	GET /feed-posts/{tenantId}/user-reacts
PublicApi	lockComment	POST /comments/{tenantId}/{commentId}/lock
PublicApi	pinComment	POST /comments/{tenantId}/{commentId}/pin
PublicApi	reactFeedPostPublic	POST /feed-posts/{tenantId}/react/{postId}
PublicApi	resetUserNotificationCount	POST /user-notifications/reset-count
PublicApi	resetUserNotifications	POST /user-notifications/reset
PublicApi	searchUsers	GET /user-search/{tenantId}
PublicApi	setCommentText	POST /comments/{tenantId}/{commentId}/update-text
PublicApi	unBlockCommentPublic	DELETE /block-from-comment/{commentId}
PublicApi	unLockComment	POST /comments/{tenantId}/{commentId}/unlock
PublicApi	unPinComment	POST /comments/{tenantId}/{commentId}/unpin
PublicApi	updateFeedPostPublic	PUT /feed-posts/{tenantId}/{postId}
PublicApi	updateUserNotificationCommentSubscriptionStatus	POST /user-notifications/{notificationId}/mark-opted/{optedInOrOut}	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

Parámetros

Name	Type	Requerido
tenantId	string	Sí
aggregationRequest	AggregationRequest	Sí
parentTenantId	string	No
includeStats	bool	No

Respuesta

Devuelve: AggregationResponse

Ejemplo

Ejemplo de aggregate

Copy

utility::string_t tenantId = U("my-tenant-123");
AggregationRequest aggReq;
boost::optional<utility::string_t> parentTenant = boost::optional<utility::string_t>(U("parent-org-456"));
boost::optional<bool> includeStats = boost::optional<bool>(true);
auto aggTask = api->aggregate(tenantId, aggReq, parentTenant, includeStats)
    .then([](pplx::task<std::shared_ptr<AggregationResponse>> t) {
        try {
            auto res = t.get();
            auto out = std::make_shared<AggregationResponse>(*res);
            return out;
        } catch (...) {
            return std::shared_ptr<AggregationResponse>();
        }
    });

Obtener registros de auditoría

Parámetros

Nombre	Type	Obligatorio
tenantId	string	Sí
limit	double	No
skip	double	No
order	SORT_DIR	No
after	double	No
before	double	No

Respuesta

Devuelve: GetAuditLogs_200_response

Ejemplo

Ejemplo de getAuditLogs

Copy

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

Bloquear desde comentario público

Parámetros

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

Respuesta

Devuelve: BlockFromCommentPublic_200_response

Ejemplo

Ejemplo de blockFromCommentPublic

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654321");
PublicBlockFromCommentParams params;
params.reason = U("Repeated harassment");
params.durationMinutes = 1440;
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-token-abc123"));
auto placeholder = std::make_shared<BlockFromCommentPublic_200_response>();
api->blockFromCommentPublic(tenantId, commentId, params, sso)
.then([](pplx::task<std::shared_ptr<BlockFromCommentPublic_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) std::wcout << U("Comment blocked successfully\n");
        else std::wcout << U("Block request returned empty response\n");
    } catch (...) {
        std::wcout << U("Block request failed\n");
    }
});

Desbloquear comentario público

Parámetros

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

Respuesta

Devuelve: UnBlockCommentPublic_200_response

Ejemplo

Ejemplo de unBlockCommentPublic

Copy

auto publicParams = std::make_shared<PublicBlockFromCommentParams>();
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(utility::string_t(U("user@example.com")));
api->unBlockCommentPublic(utility::string_t(U("my-tenant-123")), utility::string_t(U("comment-98765")), *publicParams, sso)
.then([](pplx::task<std::shared_ptr<UnBlockCommentPublic_200_response>> task) {
    try {
        auto resp = task.get();
        if (resp) std::cout << "Unblocked comment successfully" << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Unblock failed: " << e.what() << std::endl;
    }
});

Comprobar comentarios bloqueados

Parámetros

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

Respuesta

Devuelve: CheckedCommentsForBlocked_200_response

Ejemplo

Ejemplo de checkedCommentsForBlocked

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
utility::string_t commentIds = utility::conversions::to_string_t("cmt-456,cmt-789");
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("user@example.com");
auto task = api->checkedCommentsForBlocked(tenantId, commentIds, sso)
    .then([=](std::shared_ptr<CheckedCommentsForBlocked_200_response> resp) -> std::shared_ptr<CheckedCommentsForBlocked_200_response> {
        if (!resp) return std::make_shared<CheckedCommentsForBlocked_200_response>();
        return resp;
    });

Bloquear usuario desde comentario

Parámetros

Name	Type	Requerido
tenantId	string	Sí
id	string	Sí
blockFromCommentParams	BlockFromCommentParams	Sí
userId	string	No
anonUserId	string	No

Respuesta

Devuelve: BlockFromCommentPublic_200_response

Ejemplo

Ejemplo de blockUserFromComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
auto blockParams = std::make_shared<BlockFromCommentParams>();
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<utility::string_t> anonUserId = boost::optional<utility::string_t>(U("anon-98765"));
api->blockUserFromComment(tenantId, commentId, *blockParams, userId, anonUserId)
.then([](std::shared_ptr<BlockFromCommentPublic_200_response> resp){
    if (resp) {
        std::cout << "User blocked successfully\n";
    } else {
        std::cout << "Block request returned empty response\n";
    }
}).wait();

Crear comentario público

Parámetros

Name	Type	Requerido
tenantId	string	Sí
urlId	string	Sí
broadcastId	string	Sí
commentData	CommentData	Sí
sessionId	string	No
sso	string	No

Respuesta

Devuelve: CreateCommentPublic_200_response

Ejemplo

Ejemplo de createCommentPublic

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("/articles/2026/fastcomments-cpp-integration");
utility::string_t broadcastId = U("broadcast-001");
CommentData commentData;
commentData.content = U("Hello from the C++ SDK — great article!");
commentData.authorEmail = U("reader@example.com");
commentData.authorName = U("Jane Reader");
boost::optional<utility::string_t> sessionId = boost::optional<utility::string_t>(U("sess-9f3a2"));
boost::optional<utility::string_t> sso = boost::none;
auto task = api->createCommentPublic(tenantId, urlId, broadcastId, commentData, sessionId, sso)
    .then([](pplx::task<std::shared_ptr<CreateCommentPublic_200_response>> t) {
        try {
            auto resp = t.get();
            if (resp) {
                auto resultCopy = std::make_shared<CreateCommentPublic_200_response>(*resp);
            }
        } catch (const std::exception&) {}
    });
task.wait();

Eliminar comentario

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
id	string	Sí
contextUserId	string	No
isLive	bool	No

Respuesta

Devuelve: DeleteComment_200_response

Ejemplo

Ejemplo de deleteComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654321");
boost::optional<utility::string_t> contextUserId = boost::optional<utility::string_t>(U("moderator@acme.com"));
boost::optional<bool> isLive = boost::optional<bool>(true);
api->deleteComment(tenantId, commentId, contextUserId, isLive)
.then([](pplx::task<std::shared_ptr<DeleteComment_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto processed = std::make_shared<DeleteComment_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

Eliminar comentario público

Parámetros

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

Respuesta

Devuelve: DeleteCommentPublic_200_response

Ejemplo

Ejemplo de deleteCommentPublic

Copy

utility::string_t tenantId(U("my-tenant-123"));
utility::string_t commentId(U("cmt-456"));
utility::string_t broadcastId(U("brd-789"));
boost::optional<utility::string_t> editKey = boost::optional<utility::string_t>(utility::string_t(U("editkey-abc123")));
boost::optional<utility::string_t> sso; 
api->deleteCommentPublic(tenantId, commentId, broadcastId, editKey, sso)
.then([](pplx::task<std::shared_ptr<DeleteCommentPublic_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto copied = std::make_shared<DeleteCommentPublic_200_response>(*resp);
            (void)copied;
        }
    } catch (const std::exception&) {
        auto fallback = std::make_shared<DeleteCommentPublic_200_response>();
        (void)fallback;
    }
});

Eliminar voto de comentario

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
commentId	string	Sí
voteId	string	Sí
urlId	string	Sí
broadcastId	string	Sí
editKey	string	No
sso	string	No

Respuesta

Devuelve: DeleteCommentVote_200_response

Ejemplo

Ejemplo de deleteCommentVote

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-789");
utility::string_t voteId = U("vote-456");
utility::string_t urlId = U("/articles/2026/fastcomments-guide");
utility::string_t broadcastId = U("broadcast-001");
boost::optional<utility::string_t> editKey = boost::optional<utility::string_t>(U("editkey-abc"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
auto placeholder = std::make_shared<DeleteCommentVote_200_response>();
api->deleteCommentVote(tenantId, commentId, voteId, urlId, broadcastId, editKey, sso)
.then([=](pplx::task<std::shared_ptr<DeleteCommentVote_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) std::cout << "Vote deleted\n";
    } catch (const std::exception &e) {
        std::cerr << "Delete failed: " << e.what() << '\n';
    }
});

Marcar comentario

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
id	string	Sí
userId	string	No
anonUserId	string	No

Respuesta

Devuelve: FlagComment_200_response

Ejemplo

Ejemplo de flagComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
boost::optional<utility::string_t> userId{ utility::string_t(U("user@example.com")) };
boost::optional<utility::string_t> anonUserId;
api->flagComment(tenantId, commentId, userId, anonUserId)
.then([](std::shared_ptr<FlagComment_200_response> resp) {
    auto result = resp ? resp : std::make_shared<FlagComment_200_response>();
    (void)result;
});

Obtener comentario

Parámetros

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

Respuesta

Devuelve: GetComment_200_response

Ejemplo

Ejemplo de getComment

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> maybeId = utility::conversions::to_string_t("comment-98765");
auto getTask = api->getComment(tenantId, *maybeId)
    .then([](pplx::task<std::shared_ptr<GetComment_200_response>> t) {
        try {
            auto resp = t.get();
            auto result = resp ? resp : std::make_shared<GetComment_200_response>();
            return result;
        } catch (const std::exception&) {
            return std::make_shared<GetComment_200_response>();
        }
    });

Obtener comentarios

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
page	int32_t	No
limit	int32_t	No
skip	int32_t	No
asTree	bool	No
skipChildren	int32_t	No
limitChildren	int32_t	No
maxTreeDepth	int32_t	No
urlId	string	No
userId	string	No
anonUserId	string	No
contextUserId	string	No
hashTag	string	No
parentId	string	No
direction	SortDirections	No

Respuesta

Devuelve: GetComments_200_response

Ejemplo

Ejemplo de getComments

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<int32_t> page(1);
boost::optional<int32_t> limit(50);
boost::optional<int32_t> skip(0);
boost::optional<bool> asTree(true);
boost::optional<int32_t> skipChildren(0);
boost::optional<int32_t> limitChildren(10);
boost::optional<int32_t> maxTreeDepth(3);
boost::optional<utility::string_t> urlId(U("/articles/2025/fast-api"));
boost::optional<utility::string_t> userId(U("user@example.com"));
boost::optional<utility::string_t> anonUserId(U("anon-abc-123"));
boost::optional<utility::string_t> contextUserId(U("context-user-789"));
boost::optional<utility::string_t> hashTag(U("release"));
boost::optional<utility::string_t> parentId(U("parent-comment-456"));
boost::optional<SortDirections> direction(SortDirections::DESCENDING);
api->getComments(tenantId, page, limit, skip, asTree, skipChildren, limitChildren, maxTreeDepth, urlId, userId, anonUserId, contextUserId, hashTag, parentId, direction)
.then([](pplx::task<std::shared_ptr<GetComments_200_response>> task){
    try {
        auto response = task.get();
        if (!response) response = std::make_shared<GetComments_200_response>();
    } catch (const std::exception&) {
    }
});

Obtener comentarios públicos

req tenantId urlId

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
urlId	string	Sí
page	int32_t	No
direction	SortDirections	No
sso	string	No
skip	int32_t	No
skipChildren	int32_t	No
limit	int32_t	No
limitChildren	int32_t	No
countChildren	bool	No
fetchPageForCommentId	string	No
includeConfig	bool	No
countAll	bool	No
includei10n	bool	No
locale	string	No
modules	string	No
isCrawler	bool	No
includeNotificationCount	bool	No
asTree	bool	No
maxTreeDepth	int32_t	No
useFullTranslationIds	bool	No
parentId	string	No
searchText	string	No
hashTags	vector<string	No
userId	string	No
customConfigStr	string	No
afterCommentId	string	No
beforeCommentId	string	No

Respuesta

Devuelve: GetCommentsPublic_200_response

Ejemplo

getCommentsPublic Example

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("article-2026-01-12");
boost::optional<int32_t> page(2);
boost::optional<SortDirections> direction(SortDirections::DESC);
boost::optional<bool> includeConfig(true);
boost::optional<std::vector<utility::string_t>> hashTags(std::vector<utility::string_t>{ U("feature"), U("bug") });
api->getCommentsPublic(
    tenantId,
    urlId,
    page,
    direction,
    boost::optional<utility::string_t>(),
    boost::optional<int32_t>(),
    boost::optional<int32_t>(),
    boost::optional<int32_t>(50),
    boost::optional<int32_t>(),
    boost::optional<bool>(false),
    boost::optional<utility::string_t>(),
    includeConfig,
    boost::optional<bool>(),
    boost::optional<bool>(),
    boost::optional<utility::string_t>(),
    boost::optional<utility::string_t>(),
    boost::optional<bool>(),
    boost::optional<bool>(),
    boost::optional<bool>(),
    boost::optional<int32_t>(),
    boost::optional<bool>(),
    boost::optional<utility::string_t>(),
    boost::optional<utility::string_t>(),
    hashTags,
    boost::optional<utility::string_t>(U("user-789")),
    boost::optional<utility::string_t>(),
    boost::optional<utility::string_t>()
).then([](pplx::task<std::shared_ptr<GetCommentsPublic_200_response>> t){
    try {
        auto resp = t.get();
        auto fallback = std::make_shared<GetCommentsPublic_200_response>();
        (void)(resp ? resp : fallback);
    } catch (...) {}
});

Obtener texto del comentario

Parámetros

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

Respuesta

Devuelve: GetCommentText_200_response

Ejemplo

Ejemplo de getCommentText

Copy

utility::string_t tenantId(U("my-tenant-123"));
utility::string_t commentId(U("cmt-456"));
boost::optional<utility::string_t> editKey(utility::string_t(U("edit-key-789")));
boost::optional<utility::string_t> sso(utility::string_t(U("user@example.com")));
auto task = api->getCommentText(tenantId, commentId, editKey, sso)
    .then([](std::shared_ptr<GetCommentText_200_response> resp){
        if (resp) {
            std::cout << "Comment text retrieved\n";
        } else {
            std::cout << "Comment not found\n";
        }
    });
task.wait();

Obtener nombres de usuarios que votaron el comentario

Parámetros

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

Respuesta

Devuelve: GetCommentVoteUserNames_200_response

Ejemplo

Ejemplo de getCommentVoteUserNames

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456");
int32_t dir = 1;
boost::optional<utility::string_t> sso{ utility::string_t(U("user@example.com")) };
api->getCommentVoteUserNames(tenantId, commentId, dir, sso)
    .then([](pplx::task<std::shared_ptr<GetCommentVoteUserNames_200_response>> t) {
        try {
            auto resp = t.get();
            if (!resp) resp = std::make_shared<GetCommentVoteUserNames_200_response>();
        } 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: LockComment_200_response

Ejemplo

Ejemplo de lockComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456");
utility::string_t broadcastId = U("brdcst-789");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
api->lockComment(tenantId, commentId, broadcastId, sso)
    .then([](pplx::task<std::shared_ptr<LockComment_200_response>> t)
    {
        try
        {
            auto resp = t.get();
            if(!resp)
            {
                resp = std::make_shared<LockComment_200_response>();
            }
        }
        catch(const std::exception& ex)
        {
            (void)ex;
        }
    });

Anclar comentario

Parámetros

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

Respuesta

Devuelve: PinComment_200_response

Ejemplo

Ejemplo de pinComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
utility::string_t broadcastId = U("broadcast-98765");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
api->pinComment(tenantId, commentId, broadcastId, sso)
.then([](pplx::task<std::shared_ptr<PinComment_200_response>> t){
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<PinComment_200_response>();
        (void)resp;
    } catch (...) {}
}).wait();

Guardar comentario

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
createCommentParams	CreateCommentParams	Sí
isLive	bool	No
doSpamCheck	bool	No
sendEmails	bool	No
populateNotifications	bool	No

Respuesta

Devuelve: SaveComment_200_response

Ejemplo

Ejemplo de saveComment

Copy

utility::string_t tenantId = U("my-tenant-123");
auto createParamsPtr = std::make_shared<CreateCommentParams>();
createParamsPtr->content = utility::string_t(U("This is a test comment posted via SDK"));
createParamsPtr->authorEmail = utility::string_t(U("user@example.com"));
createParamsPtr->threadId = utility::string_t(U("thread-456"));
boost::optional<bool> isLive(true);
boost::optional<bool> doSpamCheck(false);
boost::optional<bool> sendEmails(true);
boost::optional<bool> populateNotifications(false);
auto task = api->saveComment(tenantId, *createParamsPtr, isLive, doSpamCheck, sendEmails, populateNotifications)
.then([](std::shared_ptr<SaveComment_200_response> resp){
    if (resp) std::cout << "Comment saved successfully\n";
    else std::cout << "Failed to save comment\n";
});
task.wait();

Establecer texto del comentario

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
commentId	string	Sí
broadcastId	string	Sí
commentTextUpdateRequest	CommentTextUpdateRequest	Sí
editKey	string	No
sso	string	No

Respuesta

Devuelve: SetCommentText_200_response

Ejemplo

Ejemplo de setCommentText

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456");
utility::string_t broadcastId = U("bcast-789");
CommentTextUpdateRequest commentTextUpdateRequest;
commentTextUpdateRequest.setText(U("Updated comment text by moderator."));
boost::optional<utility::string_t> editKey = boost::optional<utility::string_t>(U("edit-key-abc123"));
boost::optional<utility::string_t> sso;
api->setCommentText(tenantId, commentId, broadcastId, commentTextUpdateRequest, editKey, sso)
.then([](pplx::task<std::shared_ptr<SetCommentText_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto result = std::make_shared<SetCommentText_200_response>(*resp);
            std::cout << "Comment updated\n";
        } else {
            std::cout << "No response\n";
        }
    } catch (const std::exception &e) {
        std::cerr << "setCommentText error: " << e.what() << '\n';
    }
});

Desbloquear usuario del comentario

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
unBlockFromCommentParams	UnBlockFromCommentParams	Sí
userId	string	No
anonUserId	string	No

Respuesta

Devuelve: UnBlockCommentPublic_200_response

Ejemplo

Ejemplo de unBlockUserFromComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
auto paramsPtr = std::make_shared<UnBlockFromCommentParams>();
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<utility::string_t> anonUserId = boost::none;
api->unBlockUserFromComment(tenantId, commentId, *paramsPtr, userId, anonUserId)
    .then([](std::shared_ptr<UnBlockCommentPublic_200_response> resp){
        (void)resp;
    })
    .wait();

Desmarcar comentario

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
id	string	Sí
userId	string	No
anonUserId	string	No

Respuesta

Devuelve: FlagComment_200_response

Ejemplo

Ejemplo de unFlagComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654321");
boost::optional<utility::string_t> userId(U("user@example.com"));
boost::optional<utility::string_t> anonUserId;
auto fallback = std::make_shared<FlagComment_200_response>();
api->unFlagComment(tenantId, commentId, userId, anonUserId)
    .then([fallback](pplx::task<std::shared_ptr<FlagComment_200_response>> t) {
        try {
            auto resp = t.get();
            if (!resp) resp = fallback;
        } catch (...) {
        }
    });

Desbloquear comentario

Parámetros

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

Respuesta

Devuelve: LockComment_200_response

Ejemplo

Ejemplo de unLockComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654");
utility::string_t broadcastId = U("brd-456");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
auto dummyResp = std::make_shared<LockComment_200_response>();
api->unLockComment(tenantId, commentId, broadcastId, sso)
.then([](pplx::task<std::shared_ptr<LockComment_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            std::cout << "Comment unlocked successfully\n";
        } else {
            std::cout << "Unlock returned empty response\n";
        }
    } catch (const std::exception& e) {
        std::cerr << "Error unlocking comment: " << e.what() << '\n';
    }
});

Desanclar comentario

Parámetros

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

Respuesta

Devuelve: PinComment_200_response

Ejemplo

Ejemplo de unPinComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
utility::string_t broadcastId = U("brd-98765");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
auto defaultResp = std::make_shared<PinComment_200_response>();
api->unPinComment(tenantId, commentId, broadcastId, sso)
.then([defaultResp](pplx::task<std::shared_ptr<PinComment_200_response>> task) {
    try {
        auto resp = task.get();
        if (!resp) resp = defaultResp;
        std::cout << "unPinComment completed; response pointer " << (resp ? "valid" : "null") << std::endl;
    } catch (const std::exception &e) {
        std::cerr << "unPinComment failed: " << e.what() << std::endl;
    }
});

Actualizar comentario

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
id	string	Sí
updatableCommentParams	UpdatableCommentParams	Sí
contextUserId	string	No
doSpamCheck	bool	No
isLive	bool	No

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de updateComment

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto commentId = utility::string_t(U("comment-456"));
auto body = std::make_shared<UpdatableCommentParams>();
body->content = utility::string_t(U("Updated comment text: fixed a typo and clarified meaning."));
boost::optional<utility::string_t> contextUserId(utility::string_t(U("user@example.com")));
boost::optional<bool> doSpamCheck(true);
boost::optional<bool> isLive(false);
api->updateComment(tenantId, commentId, body, contextUserId, doSpamCheck, isLive)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
    try {
        auto result = t.get();
        (void)result;
    } catch (...) {}
});

Votar comentario

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
commentId	string	Sí
urlId	string	Sí
broadcastId	string	Sí
voteBodyParams	VoteBodyParams	Sí
sessionId	string	No
sso	string	No

Respuesta

Devuelve: VoteComment_200_response

Ejemplo

Ejemplo de voteComment

Copy

VoteBodyParams voteBodyParams;
utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-7890");
utility::string_t urlId = U("/articles/2025/how-to-cpprest");
utility::string_t broadcastId = U("broadcast-321");
boost::optional<utility::string_t> sessionId = boost::optional<utility::string_t>(U("sess-0a1b2c"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-jwt-xyz"));
api->voteComment(tenantId, commentId, urlId, broadcastId, voteBodyParams, sessionId, sso)
    .then([](pplx::task<std::shared_ptr<VoteComment_200_response>> t) {
        try {
            auto resp = t.get();
            if (!resp) resp = std::make_shared<VoteComment_200_response>();
        } catch (...) {
        }
    });

Agregar configuración de dominio

Parámetros

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

Respuesta

Devuelve: AddDomainConfig_200_response

Ejemplo

Ejemplo de addDomainConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
AddDomainConfigParams params;
params.domain = U("comments.example.com");
params.allowSubdomains = boost::optional<bool>(true);
params.contactEmail = boost::optional<utility::string_t>(U("admin@example.com"));
api->addDomainConfig(tenantId, params)
.then([](pplx::task<std::shared_ptr<AddDomainConfig_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<AddDomainConfig_200_response>(*resp);
            (void)copy;
        }
    } catch (const std::exception& e) {
        (void)e;
    }
});

Eliminar configuración de dominio

Parámetros

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

Respuesta

Devuelve: DeleteDomainConfig_200_response

Ejemplo

Ejemplo de deleteDomainConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domain = U("comments.example.com");
boost::optional<utility::string_t> ifMatch = boost::optional<utility::string_t>(U("W/\"abc123\""));
api->deleteDomainConfig(tenantId, domain)
.then([](pplx::task<std::shared_ptr<DeleteDomainConfig_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            auto resultCopy = std::make_shared<DeleteDomainConfig_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

Obtener configuración de dominio

Parámetros

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

Respuesta

Devuelve: GetDomainConfig_200_response

Ejemplo

Ejemplo de getDomainConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domain = U("example.com");
boost::optional<utility::string_t> env = boost::optional<utility::string_t>(U("production"));
api->getDomainConfig(tenantId, domain).then([=](pplx::task<std::shared_ptr<GetDomainConfig_200_response>> t) {
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<GetDomainConfig_200_response>();
        std::cout << "Domain config received for " << utility::conversions::to_utf8string(domain) << '\n';
    } catch (const std::exception &ex) {
        std::cerr << "Failed to get domain config: " << ex.what() << '\n';
    }
});

Obtener configuraciones de dominio

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí

Respuesta

Devuelve: GetDomainConfigs_200_response

Ejemplo

Ejemplo de getDomainConfigs

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> requestId = utility::conversions::to_string_t("req-789");
api->getDomainConfigs(tenantId)
    .then([requestId](pplx::task<std::shared_ptr<GetDomainConfigs_200_response>> t){
        try {
            auto resp = t.get();
            auto copy = std::make_shared<GetDomainConfigs_200_response>(*resp);
            if (requestId) std::cout << "Request id present\n";
            std::cout << "Domain configs loaded\n";
        } catch (const std::exception &e) {
            std::cerr << "Error: " << e.what() << '\n';
        }
    }).wait();

Modificar parcialmente configuración de dominio

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
domainToUpdate	string	Sí
patchDomainConfigParams	PatchDomainConfigParams	Sí

Respuesta

Devuelve: GetDomainConfig_200_response

Ejemplo

Ejemplo de patchDomainConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domainToUpdate = U("example.com");
PatchDomainConfigParams params;
params.adminEmail = boost::optional<utility::string_t>(U("admin@example.com"));
params.enableSso = boost::optional<bool>(true);
params.ssoRedirectUrl = boost::optional<utility::string_t>(U("https://auth.example.com/callback"));
api->patchDomainConfig(tenantId, domainToUpdate, params)
    .then([](pplx::task<std::shared_ptr<GetDomainConfig_200_response>> task){
        try {
            auto resp = task.get();
            if (resp) {
                auto updated = std::make_shared<GetDomainConfig_200_response>(*resp);
            }
        } catch (const std::exception& e) {
            auto err = std::string(e.what());
        }
    });

Reemplazar configuración de dominio

Parámetros

Name	Type	Required
tenantId	string	Sí
domainToUpdate	string	Sí
updateDomainConfigParams	UpdateDomainConfigParams	Sí

Respuesta

Devuelve: GetDomainConfig_200_response

Ejemplo

Ejemplo de putDomainConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domainToUpdate = U("comments.myapp.com");
auto params = std::make_shared<UpdateDomainConfigParams>();
params->displayName = utility::string_t(U("My App Comments"));
params->enabled = boost::optional<bool>(true);
params->contactEmail = boost::optional<utility::string_t>(U("admin@myapp.com"));
api->putDomainConfig(tenantId, domainToUpdate, *params)
.then([](pplx::task<std::shared_ptr<GetDomainConfig_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto updated = resp;
        }
    } catch (const std::exception& e) {
    }
});

Crear plantilla de correo

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
createEmailTemplateBody	CreateEmailTemplateBody	Sí

Respuesta

Devuelve: CreateEmailTemplate_200_response

Ejemplo

Ejemplo de createEmailTemplate

Copy

utility::string_t tenantId = U("my-tenant-123");
auto body = std::make_shared<CreateEmailTemplateBody>();
body->name = utility::string_t(U("Welcome Email"));
body->subject = utility::string_t(U("Welcome to Our Service"));
body->fromEmail = utility::string_t(U("no-reply@mycompany.com"));
body->fromName = utility::string_t(U("MyCompany Support"));
body->html = utility::string_t(U("<p>Hello {{user.name}}, welcome to MyCompany.</p>"));
body->description = boost::optional<utility::string_t>(utility::string_t(U("Onboarding welcome template")));
api->createEmailTemplate(tenantId, *body)
.then([](pplx::task<std::shared_ptr<CreateEmailTemplate_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            bool created = true;
            (void)created;
        }
    } catch (const std::exception&) {
    }
});

Eliminar plantilla de correo

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de deleteEmailTemplate

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email-template-456");
boost::optional<utility::string_t> requestNote = boost::optional<utility::string_t>(U("remove-obsolete"));
auto fallback = std::make_shared<FlagCommentPublic_200_response>();
api->deleteEmailTemplate(tenantId, templateId)
.then([requestNote, fallback](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) -> pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> {
    try {
        auto resp = t.get();
        if (resp) return pplx::task_from_result(resp);
        if (requestNote) return pplx::task_from_result(fallback);
        return pplx::task_from_result<std::shared_ptr<FlagCommentPublic_200_response>>(nullptr);
    } catch (...) {
        return pplx::task_from_result<std::shared_ptr<FlagCommentPublic_200_response>>(nullptr);
    }
});

Eliminar error de renderizado de plantilla de correo

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de deleteEmailTemplateRenderError

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email-template-456");
utility::string_t errorId = U("render-error-789");
auto placeholder = std::make_shared<FlagCommentPublic_200_response>();
boost::optional<utility::string_t> operatorNote = boost::none;
operatorNote = U("auto-resolved");
api->deleteEmailTemplateRenderError(tenantId, templateId, errorId)
    .then([operatorNote, templateId](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> previous) {
        try {
            auto resp = previous.get();
            if (resp) {
                std::cout << "Successfully deleted render error for template: " << utility::conversions::to_utf8string(templateId) << std::endl;
            }
            if (operatorNote) {
                std::cout << "Note: " << utility::conversions::to_utf8string(operatorNote.value()) << std::endl;
            }
        } catch (const std::exception &e) {
            std::cerr << "API error: " << e.what() << std::endl;
        }
    });

Obtener plantilla de correo

Parámetros

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

Respuesta

Devuelve: GetEmailTemplate_200_response

Ejemplo

Ejemplo de getEmailTemplate

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email-001");
boost::optional<utility::string_t> preferLocale = boost::optional<utility::string_t>(U("en-US"));
api->getEmailTemplate(tenantId, templateId)
    .then([preferLocale](std::shared_ptr<GetEmailTemplate_200_response> resp) {
        auto templateResp = resp ? resp : std::make_shared<GetEmailTemplate_200_response>();
        if (preferLocale) {
            (void)preferLocale;
        }
        return templateResp;
    });

Obtener definiciones de plantilla de correo

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí

Respuesta

Devuelve: GetEmailTemplateDefinitions_200_response

Ejemplo

Ejemplo de getEmailTemplateDefinitions

Copy

boost::optional<utility::string_t> tenantIdOpt = utility::string_t(U("my-tenant-123"));
api->getEmailTemplateDefinitions(tenantIdOpt.value())
.then([](pplx::task<std::shared_ptr<GetEmailTemplateDefinitions_200_response>> task) {
    try {
        auto resp = task.get();
        auto localCopy = std::make_shared<GetEmailTemplateDefinitions_200_response>(*resp);
        (void)localCopy;
    } catch (const std::exception& e) {
        auto fallback = std::make_shared<GetEmailTemplateDefinitions_200_response>();
        (void)fallback;
    }
});

Obtener errores de renderizado de plantilla de correo

Parámetros

Name	Type	Required
tenantId	string	Sí
id	string	Sí
skip	double	No

Respuesta

Devuelve: GetEmailTemplateRenderErrors_200_response

Ejemplo

Ejemplo de getEmailTemplateRenderErrors

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("email-template-789");
boost::optional<double> skip{10.0};
auto defaultResp = std::make_shared<GetEmailTemplateRenderErrors_200_response>();
api->getEmailTemplateRenderErrors(tenantId, id, skip).then([defaultResp](pplx::task<std::shared_ptr<GetEmailTemplateRenderErrors_200_response>> t){
    try {
        auto resp = t.get();
        if(!resp) resp = defaultResp;
        std::wcout << (resp ? U("Received render errors response\n") : U("No response\n"));
    } catch(...) {
        std::wcout << U("Failed to retrieve render errors\n");
    }
});

Obtener plantillas de correo

Parámetros

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

Respuesta

Devuelve: GetEmailTemplates_200_response

Ejemplo

Ejemplo de getEmailTemplates

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = 10.0;
api->getEmailTemplates(tenantId, skip).then([](pplx::task<std::shared_ptr<GetEmailTemplates_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<GetEmailTemplates_200_response>(*resp);
        }
    } catch (const std::exception& e) {
        (void)e;
    }
});

Renderizar plantilla de correo

Parámetros

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

Respuesta

Devuelve: RenderEmailTemplate_200_response

Ejemplo

Ejemplo de renderEmailTemplate

Copy

utility::string_t tenantId = U("my-tenant-123");
RenderEmailTemplateBody renderEmailTemplateBody;
renderEmailTemplateBody.setTemplateName(U("welcome_wagon"));
renderEmailTemplateBody.setRecipient(U("alice@example.com"));
web::json::value vars;
vars[U("firstName")] = web::json::value::string(U("Alice"));
renderEmailTemplateBody.setVariables(vars);
boost::optional<utility::string_t> locale = boost::optional<utility::string_t>(U("en-US"));
auto placeholder = std::make_shared<RenderEmailTemplate_200_response>();
api->renderEmailTemplate(tenantId, renderEmailTemplateBody, locale)
.then([](pplx::task<std::shared_ptr<RenderEmailTemplate_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            std::cout << "Email template rendered successfully" << std::endl;
        } else {
            std::cerr << "No response returned" << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << "Render failed: " << e.what() << std::endl;
    }
});

Actualizar plantilla de correo

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de updateEmailTemplate

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email-01");
UpdateEmailTemplateBody updateBody;
boost::optional<utility::string_t> optionalFrom = boost::optional<utility::string_t>(U("no-reply@myapp.com"));
updateBody.from = optionalFrom;
updateBody.subject = U("Welcome to MyApp");
updateBody.html = U("<p>Hi {{displayName}}, welcome to MyApp!</p>");
auto bodyPtr = std::make_shared<UpdateEmailTemplateBody>(updateBody);
api->updateEmailTemplate(tenantId, templateId, *bodyPtr)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            std::cout << "Email template updated successfully\n";
        } else {
            std::cout << "Unexpected empty response\n";
        }
    } catch (const std::exception &e) {
        std::cerr << "Update failed: " << e.what() << '\n';
    }
});

Obtener registro de eventos

req tenantId urlId userIdWS

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
urlId	string	Sí
userIdWS	string	Sí
startTime	int64_t	Sí
endTime	int64_t	Sí

Respuesta

Devuelve: GetEventLog_200_response

Ejemplo

Ejemplo de getEventLog

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("article-456");
utility::string_t userIdWS = U("user@example.com");
int64_t startTime = 1672531200LL;
boost::optional<int64_t> endTimeOpt = 1672617600LL;
api->getEventLog(tenantId, urlId, userIdWS, startTime, *endTimeOpt)
    .then([](pplx::task<std::shared_ptr<GetEventLog_200_response>> t){
        try {
            auto resp = t.get();
            if (!resp) resp = std::make_shared<GetEventLog_200_response>();
        } catch (const std::exception&) {}
    });

Obtener registro global de eventos

req tenantId urlId userIdWS

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
urlId	string	Sí
userIdWS	string	Sí
startTime	int64_t	Sí
endTime	int64_t	Sí

Respuesta

Devuelve: GetEventLog_200_response

Ejemplo

Ejemplo de getGlobalEventLog

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t defaultUrlId = U("article-456");
boost::optional<utility::string_t> maybeUrlId = boost::optional<utility::string_t>(U("article-456"));
utility::string_t urlId = maybeUrlId ? *maybeUrlId : defaultUrlId;
utility::string_t userIdWS = U("user@example.com");
int64_t startTime = 1622505600000LL;
int64_t endTime = 1622592000000LL;
auto defaultResp = std::make_shared<GetEventLog_200_response>();
api->getGlobalEventLog(tenantId, urlId, userIdWS, startTime, endTime)
.then([](pplx::task<std::shared_ptr<GetEventLog_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) std::cout << "Received event log with entries\n";
        else std::cout << "No event log returned\n";
    } catch (const std::exception &e) {
        std::cerr << "getGlobalEventLog failed: " << e.what() << '\n';
    }
});

Crear publicación del feed

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
createFeedPostParams	CreateFeedPostParams	Sí
broadcastId	string	No
isLive	bool	No
doSpamCheck	bool	No
skipDupCheck	bool	No

Respuesta

Devuelve: CreateFeedPost_200_response

Ejemplo

Ejemplo de createFeedPost

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateFeedPostParams params;
params.title = utility::string_t(U("Weekly Product Update"));
params.content = utility::string_t(U("This week we shipped several improvements to the API."));
params.authorEmail = utility::string_t(U("jane.doe@example.com"));
boost::optional<utility::string_t> broadcastId = boost::optional<utility::string_t>(U("broadcast-456"));
boost::optional<bool> isLive = boost::optional<bool>(true);
boost::optional<bool> doSpamCheck = boost::optional<bool>(false);
boost::optional<bool> skipDupCheck = boost::optional<bool>(false);
api->createFeedPost(tenantId, params, broadcastId, isLive, doSpamCheck, skipDupCheck)
.then([](pplx::task<std::shared_ptr<CreateFeedPost_200_response>> t){
    try {
        auto resp = t.get();
        auto copy = std::make_shared<CreateFeedPost_200_response>(*resp);
    } catch (...) {}
});

Crear publicación del feed pública

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
createFeedPostParams	CreateFeedPostParams	Sí
broadcastId	string	No
sso	string	No

Respuesta

Devuelve: CreateFeedPostPublic_200_response

Ejemplo

Ejemplo de createFeedPostPublic

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto paramsPtr = std::make_shared<CreateFeedPostParams>();
paramsPtr->title = utility::string_t(U("Weekly Release Notes"));
paramsPtr->content = utility::string_t(U("We've deployed version 2.4.1 with bug fixes and UX improvements."));
paramsPtr->authorEmail = utility::string_t(U("alice@example.com"));
boost::optional<utility::string_t> broadcastId = utility::string_t(U("broadcast-456"));
boost::optional<utility::string_t> sso = utility::string_t(U("sso-token-abc123"));
api->createFeedPostPublic(tenantId, *paramsPtr, broadcastId, sso)
    .then([](pplx::task<std::shared_ptr<CreateFeedPostPublic_200_response>> t) {
        try {
            auto resp = t.get();
            if (resp) std::cout << "Feed post created successfully\n";
        } catch (const std::exception& e) {
            std::cerr << "Failed to create feed post: " << e.what() << '\n';
        }
    });

Eliminar publicación del feed pública

Parámetros

Name	Type	Required
tenantId	string	Sí
postId	string	Sí
broadcastId	string	No
sso	string	No

Respuesta

Devuelve: DeleteFeedPostPublic_200_response

Ejemplo

Ejemplo de deleteFeedPostPublic

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t postId = U("post-456");
boost::optional<utility::string_t> broadcastId = boost::optional<utility::string_t>(U("broadcast-789"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
api->deleteFeedPostPublic(tenantId, postId, broadcastId, sso)
.then([](pplx::task<std::shared_ptr<DeleteFeedPostPublic_200_response>> t){
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<DeleteFeedPostPublic_200_response>();
        (void)resp;
    } catch (const std::exception&) {
    }
});

Obtener publicaciones del feed

Parámetros

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

Respuesta

Devuelve: GetFeedPosts_200_response

Ejemplo

Ejemplo de getFeedPosts

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> afterId(utility::string_t(U("post_456")));
boost::optional<int32_t> limit(50);
std::vector<utility::string_t> tagVec{U("news"), U("announcement")};
boost::optional<std::vector<utility::string_t>> tags(tagVec);
api->getFeedPosts(tenantId, afterId, limit, tags)
.then([](std::shared_ptr<GetFeedPosts_200_response> resp) {
    auto copy = std::make_shared<GetFeedPosts_200_response>(*resp);
    (void)copy;
});

Obtener publicaciones del feed públicas

req tenantId afterId

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
afterId	string	No
limit	int32_t	No
tags	vector<string	No
sso	string	No
isCrawler	bool	No
includeUserInfo	bool	No

Respuesta

Devuelve: GetFeedPostsPublic_200_response

Ejemplo

Ejemplo de getFeedPostsPublic

Copy

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

Obtener estadísticas de publicaciones del feed

Parámetros

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

Respuesta

Devuelve: GetFeedPostsStats_200_response

Ejemplo

Ejemplo de getFeedPostsStats

Copy

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

Obtener reacciones de usuario públicas

Parámetros

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

Respuesta

Devuelve: GetUserReactsPublic_200_response

Ejemplo

Ejemplo de getUserReactsPublic

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
std::vector<utility::string_t> postIdsVec = {
    utility::conversions::to_string_t("post-456"),
    utility::conversions::to_string_t("post-789")
};
boost::optional<std::vector<utility::string_t>> postIdsOpt = postIdsVec;
boost::optional<utility::string_t> ssoOpt = utility::conversions::to_string_t("user@example.com");
api->getUserReactsPublic(tenantId, postIdsOpt, ssoOpt)
    .then([](pplx::task<std::shared_ptr<GetUserReactsPublic_200_response>> t) {
        try {
            auto resp = t.get();
            if (!resp) resp = std::make_shared<GetUserReactsPublic_200_response>();
        } catch (const std::exception&) {
        }
    });

Reaccionar a publicación del feed pública

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
postId	string	Sí
reactBodyParams	ReactBodyParams	Sí
isUndo	bool	No
broadcastId	string	No
sso	string	No

Respuesta

Devuelve: ReactFeedPostPublic_200_response

Ejemplo

Ejemplo de reactFeedPostPublic

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t postId = U("post-987");
ReactBodyParams reactBodyParams;
reactBodyParams.userId = U("jane.doe@example.com");
reactBodyParams.reaction = U("like");
boost::optional<bool> isUndo = boost::optional<bool>(false);
boost::optional<utility::string_t> broadcastId = boost::optional<utility::string_t>(U("broadcast-001"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-token-xyz"));
api->reactFeedPostPublic(tenantId, postId, reactBodyParams, isUndo, broadcastId, sso)
    .then([](pplx::task<std::shared_ptr<ReactFeedPostPublic_200_response>> task) {
        try {
            auto resp = task.get();
            auto out = resp ? resp : std::make_shared<ReactFeedPostPublic_200_response>();
            std::cout << "Reaction processed\n";
        } catch (const std::exception &e) {
            std::cerr << "React failed: " << e.what() << '\n';
        }
    });

Actualizar publicación del feed

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de updateFeedPost

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t postId = U("post-987654321");
FeedPost feedPost;
feedPost.title = U("Weekly status update");
feedPost.content = U("Completed the migration of the comments service to the new infra.");
feedPost.authorEmail = U("developer@acme-corp.com");
boost::optional<utility::string_t> summary = boost::optional<utility::string_t>(U("Migration complete"));
feedPost.summary = summary;
auto updateTask = api->updateFeedPost(tenantId, postId, feedPost)
    .then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
        try {
            auto resp = t.get();
            if (resp) {
                auto cloned = std::make_shared<FlagCommentPublic_200_response>(*resp);
            }
        } catch (...) {
        }
    });

Actualizar publicación del feed pública

Parámetros

Name	Type	Required
tenantId	string	Sí
postId	string	Sí
updateFeedPostParams	UpdateFeedPostParams	Sí
broadcastId	string	No
sso	string	No

Respuesta

Devuelve: CreateFeedPostPublic_200_response

Ejemplo

updateFeedPostPublic Ejemplo

Copy

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

Marcar comentario público

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de flagCommentPublic

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-789012");
bool isFlagged = true;
boost::optional<utility::string_t> sso{ U("user@example.com") };
api->flagCommentPublic(tenantId, commentId, isFlagged, sso)
.then([](std::shared_ptr<FlagCommentPublic_200_response> resp){
    auto respCopy = std::make_shared<FlagCommentPublic_200_response>(*resp);
    return respCopy;
});

Agregar hashtag

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	No
createHashTagBody	CreateHashTagBody	No

Respuesta

Devuelve: AddHashTag_200_response

Ejemplo

Ejemplo de addHashTag

Copy

boost::optional<utility::string_t> tenantId(U("my-tenant-123"));
auto bodyPtr = std::make_shared<CreateHashTagBody>();
bodyPtr->name = U("release");
bodyPtr->color = U("#00aaff");
boost::optional<CreateHashTagBody> createBody(*bodyPtr);
api->addHashTag(tenantId, createBody).then([](pplx::task<std::shared_ptr<AddHashTag_200_response>> t){
    try {
        auto resp = t.get();
        (void)resp;
    } catch(...) {}
});

Agregar hashtags en lote

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	No
bulkCreateHashTagsBody	BulkCreateHashTagsBody	No

Respuesta

Devuelve: AddHashTagsBulk_200_response

Ejemplo

Ejemplo de addHashTagsBulk

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
auto bodyPtr = std::make_shared<BulkCreateHashTagsBody>();
boost::optional<utility::string_t> optTenant(tenantId);
boost::optional<BulkCreateHashTagsBody> optBody(*bodyPtr);
api->addHashTagsBulk(optTenant, optBody).then([](pplx::task<std::shared_ptr<AddHashTagsBulk_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) std::cout << "Bulk hashtags added for tenant\n";
    } catch (const std::exception &e) {
        std::cerr << "addHashTagsBulk error: " << e.what() << '\n';
    }
});

Eliminar hashtag

Parámetros

Nombre	Tipo	Requerido
tag	string	Sí
tenantId	string	No
deleteHashTagRequest	DeleteHashTag_request	No

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de deleteHashTag

Copy

utility::string_t tag = U("inappropriate");
boost::optional<utility::string_t> tenantId = boost::optional<utility::string_t>(U("my-tenant-123"));
DeleteHashTag_request req;
boost::optional<DeleteHashTag_request> optReq = boost::optional<DeleteHashTag_request>(req);
api->deleteHashTag(tag, tenantId, optReq)
.then([](std::shared_ptr<FlagCommentPublic_200_response> resp){
    auto out = std::make_shared<FlagCommentPublic_200_response>(*resp);
    std::cout << "Hashtag removed successfully for tenant\n";
    return out;
}).wait();

Obtener hashtags

Parámetros

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

Respuesta

Devuelve: GetHashTags_200_response

Ejemplo

Ejemplo de getHashTags

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> page = 2.0;
auto defaultResp = std::make_shared<GetHashTags_200_response>();
api->getHashTags(tenantId, page).then([defaultResp](pplx::task<std::shared_ptr<GetHashTags_200_response>> t) {
    try {
        auto resp = t.get();
        if(!resp) resp = defaultResp;
        std::cout << "getHashTags completed; response object " << (resp ? "present" : "absent") << std::endl;
    } catch(const std::exception& e) {
        std::cout << "getHashTags error: " << e.what() << std::endl;
    }
});

Modificar parcialmente hashtag

Parámetros

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

Respuesta

Devuelve: PatchHashTag_200_response

Ejemplo

Ejemplo de patchHashTag

Copy

utility::string_t tag = U("release-1.0");
boost::optional<utility::string_t> tenantId = boost::optional<utility::string_t>(U("my-tenant-123"));
UpdateHashTagBody body;
boost::optional<UpdateHashTagBody> updateBody = boost::optional<UpdateHashTagBody>(body);
api->patchHashTag(tag, tenantId, updateBody)
.then([](pplx::task<std::shared_ptr<PatchHashTag_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            auto copied = std::make_shared<PatchHashTag_200_response>(*resp);
            std::cout << "PatchHashTag succeeded" << std::endl;
        } else {
            std::cout << "PatchHashTag returned no data" << std::endl;
        }
    } catch (const std::exception &e) {
        std::cerr << "PatchHashTag error: " << e.what() << std::endl;
    }
});

Crear moderador

Parámetros

Name	Type	Required	Description
tenantId	string	Sí
createModeratorBody	CreateModeratorBody	Sí

Respuesta

Devuelve: CreateModerator_200_response

Ejemplo

Ejemplo de createModerator

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateModeratorBody createModeratorBody;
createModeratorBody.email = U("moderator@example.com");
createModeratorBody.displayName = U("Support Moderator");
createModeratorBody.roles = std::vector<utility::string_t>{ U("moderator"), U("support") };
createModeratorBody.notes = boost::optional<utility::string_t>(U("Temporary moderator for Q1"));
api->createModerator(tenantId, createModeratorBody)
.then([](pplx::task<std::shared_ptr<CreateModerator_200_response>> t)
{
    try
    {
        auto resp = t.get();
        auto respCopy = std::make_shared<CreateModerator_200_response>(*resp);
        (void)respCopy;
    }
    catch (const std::exception&)
    {
    }
});

Eliminar moderador

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

deleteModerator Ejemplo

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t moderatorId = U("moderator-456");
boost::optional<utility::string_t> sendEmail = boost::optional<utility::string_t>(U("moderator@notifications.example.com"));
api->deleteModerator(tenantId, moderatorId, sendEmail)
    .then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
        try {
            auto resp = t.get();
            if (!resp) resp = std::make_shared<FlagCommentPublic_200_response>();
            return resp;
        } catch (const std::exception&) {
            return std::make_shared<FlagCommentPublic_200_response>();
        }
    });

Obtener moderador

Parámetros

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Respuesta

Devuelve: GetModerator_200_response

Ejemplo

Ejemplo de getModerator

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t moderatorId = U("moderator-456");
boost::optional<utility::string_t> requestLocale = U("en-US");
auto fallbackModerator = std::make_shared<GetModerator_200_response>();
api->getModerator(tenantId, moderatorId)
    .then([fallbackModerator, requestLocale](std::shared_ptr<GetModerator_200_response> resp) -> pplx::task<std::shared_ptr<GetModerator_200_response>> {
        auto moderator = resp ? resp : fallbackModerator;
        if (requestLocale) { auto loc = *requestLocale; (void)loc; }
        return pplx::task_from_result(moderator);
    })
    .then([](std::shared_ptr<GetModerator_200_response> finalResp) -> void {
        (void)finalResp;
    });

Obtener moderadores

Parámetros

Name	Type	Required	Description
tenantId	string	Sí
skip	double	No

Respuesta

Devuelve: GetModerators_200_response

Ejemplo

Ejemplo de getModerators

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = boost::optional<double>(10);
auto task = api->getModerators(tenantId, skip)
    .then([](std::shared_ptr<GetModerators_200_response> resp) {
        if (!resp) {
            std::cout << "No moderators returned\n";
            return;
        }
        auto copy = std::make_shared<GetModerators_200_response>(*resp);
        std::cout << "Retrieved moderators\n";
    });
task.wait();

Enviar invitación

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de sendInvite

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("comment-456");
utility::string_t fromName = U("moderator@example.com");
boost::optional<utility::string_t> inviteNote = boost::optional<utility::string_t>(U("Please review this flagged comment"));
auto task = api->sendInvite(tenantId, id, fromName)
    .then([inviteNote](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) -> std::shared_ptr<FlagCommentPublic_200_response> {
        try {
            auto resp = t.get();
            auto wrapped = std::make_shared<FlagCommentPublic_200_response>(*resp);
            (void)inviteNote;
            return wrapped;
        } catch (...) {
            throw;
        }
    });

Actualizar moderador

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de updateModerator

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t moderatorId = U("moderator-456");
auto bodyPtr = std::make_shared<UpdateModeratorBody>();
bodyPtr->email = utility::string_t(U("mod.jane@example.com"));
bodyPtr->displayName = boost::optional<utility::string_t>(utility::string_t(U("Jane Moderator")));
bodyPtr->enabled = boost::optional<bool>(true);
api->updateModerator(tenantId, moderatorId, *bodyPtr).then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            std::cout << "Moderator updated successfully" << std::endl;
        }
    } catch (const std::exception &e) {
        std::cerr << "Update failed: " << e.what() << std::endl;
    }
});

Eliminar conteo de notificaciones

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de deleteNotificationCount

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t notifId = U("notification-456");
boost::optional<utility::string_t> actingUser = boost::optional<utility::string_t>(U("moderator@example.com"));
api->deleteNotificationCount(tenantId, notifId)
.then([actingUser](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<FlagCommentPublic_200_response>();
        if (actingUser) std::cout << "Actor: " << actingUser->c_str() << "\n";
        std::cout << "Notification count cleared\n";
    } catch (const std::exception &e) {
        std::cout << "Failed: " << e.what() << "\n";
    }
});

Obtener conteo de notificaciones en caché

Parámetros

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

Respuesta

Devuelve: GetCachedNotificationCount_200_response

Ejemplo

Ejemplo de getCachedNotificationCount

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user@example.com");
boost::optional<utility::string_t> opt_status = boost::optional<utility::string_t>(U("unread"));
api->getCachedNotificationCount(tenantId, userId)
    .then([=](pplx::task<std::shared_ptr<GetCachedNotificationCount_200_response>> t){
        try {
            std::shared_ptr<GetCachedNotificationCount_200_response> resp = t.get();
            if(!resp) return;
            auto copy = std::make_shared<GetCachedNotificationCount_200_response>(*resp);
        } catch(const std::exception &){
        }
    });

Obtener conteo de notificaciones

Parámetros

Name	Type	Required
tenantId	string	Sí
userId	string	No
urlId	string	No
fromCommentId	string	No
viewed	bool	No
type	string	No

Respuesta

Devuelve: GetNotificationCount_200_response

Ejemplo

Ejemplo de getNotificationCount

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> userId = U("user@example.com");
boost::optional<utility::string_t> urlId = U("https://www.example.com/article/456");
boost::optional<utility::string_t> fromCommentId = U("cmt-789");
boost::optional<bool> viewed = true;
boost::optional<utility::string_t> type = U("reply");
api->getNotificationCount(tenantId, userId, urlId, fromCommentId, viewed, type)
    .then([](pplx::task<std::shared_ptr<GetNotificationCount_200_response>> task){
        try {
            auto resp = task.get();
            auto result = resp ? resp : std::make_shared<GetNotificationCount_200_response>();
        } catch (const std::exception&) {
        }
    });

Obtener notificaciones

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
userId	string	No
urlId	string	No
fromCommentId	string	No
viewed	bool	No
type	string	No
skip	double	No

Respuesta

Devuelve: GetNotifications_200_response

Ejemplo

Ejemplo de getNotifications

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<utility::string_t> urlId = boost::optional<utility::string_t>(U("https://example.com/posts/42"));
boost::optional<utility::string_t> fromCommentId = boost::optional<utility::string_t>(U("cmt-98765"));
boost::optional<bool> viewed = boost::optional<bool>(true);
boost::optional<utility::string_t> type = boost::optional<utility::string_t>(U("reply"));
boost::optional<double> skip = boost::optional<double>(0.0);
api->getNotifications(tenantId, userId, urlId, fromCommentId, viewed, type, skip)
.then([](pplx::task<std::shared_ptr<GetNotifications_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto processed = std::make_shared<GetNotifications_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

Actualizar notificación

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de updateNotification

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t notificationId = U("notif-456");
UpdateNotificationBody updateNotificationBody;
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("moderator@example.com"));
api->updateNotification(tenantId, notificationId, updateNotificationBody, userId)
.then([=](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            auto respCopy = std::make_shared<FlagCommentPublic_200_response>(*resp);
            std::cout << "Notification updated successfully\n";
        } else {
            std::cout << "No response received\n";
        }
    } catch (const std::exception &e) {
        std::cerr << "Update failed: " << e.what() << "\n";
    }
});

Agregar página

Parámetros

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

Respuesta

Devuelve: AddPageAPIResponse

Ejemplo

Ejemplo de addPage

Copy

auto pageData = std::make_shared<CreateAPIPageData>();
pageData->url = utility::string_t(U("https://example.com/articles/2025-modern-cpp"));
pageData->title = utility::string_t(U("Modern C++ Patterns"));
pageData->description = boost::optional<utility::string_t>(utility::string_t(U("Practical patterns for modern C++ development")));
pageData->authorEmail = boost::optional<utility::string_t>(utility::string_t(U("dev@company.com")));
pageData->published = boost::optional<bool>(true);
api->addPage(utility::string_t(U("my-tenant-123")), *pageData)
.then([](pplx::task<std::shared_ptr<AddPageAPIResponse>> t){
    try {
        auto resp = t.get();
        return resp;
    } catch (...) {
        throw;
    }
});

Eliminar página

Parámetros

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

Respuesta

Devuelve: DeletePageAPIResponse

Ejemplo

Ejemplo de deletePage

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t pageId = U("page-456");
boost::optional<utility::string_t> correlationId = boost::optional<utility::string_t>(U("corr-20251122"));
auto task = api->deletePage(tenantId, pageId)
    .then([correlationId](pplx::task<std::shared_ptr<DeletePageAPIResponse>> prev) -> std::shared_ptr<DeletePageAPIResponse> {
        try {
            auto resp = prev.get();
            if (resp) return resp;
            return std::make_shared<DeletePageAPIResponse>();
        } catch (const std::exception&) {
            return std::make_shared<DeletePageAPIResponse>();
        }
    });

Obtener página por ID de URL

Parámetros

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

Respuesta

Devuelve: GetPageByURLIdAPIResponse

Ejemplo

Ejemplo de getPageByURLId

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("home-page-789");
boost::optional<utility::string_t> locale = boost::optional<utility::string_t>(U("en-US"));
api->getPageByURLId(tenantId, urlId).then([=](pplx::task<std::shared_ptr<GetPageByURLIdAPIResponse>> task){
    try {
        auto resp = task.get();
        auto result = resp ? resp : std::make_shared<GetPageByURLIdAPIResponse>();
        (void)result;
    } catch (const std::exception &ex) {
        auto err = std::make_shared<GetPageByURLIdAPIResponse>();
        (void)err;
    }
});

Obtener páginas

Parámetros

Nombre	Tipo	Obligatorio	Descripción
tenantId	string	Sí

Respuesta

Devuelve: GetPagesAPIResponse

Ejemplo

Ejemplo de getPages

Copy

int main()
{
    utility::string_t tenantId = U("my-tenant-123");
    boost::optional<utility::string_t> statusFilter = U("published");
    boost::optional<int> pageNumber = 1;
    auto placeholder = std::make_shared<GetPagesAPIResponse>();
    api->getPages(tenantId)
       .then([placeholder](std::shared_ptr<GetPagesAPIResponse> resp) {
           if (resp) {
               *placeholder = *resp;
               auto refs = resp.use_count();
               (void)refs;
           }
       })
       .wait();
    return 0;
}

Modificar parcialmente página

Parámetros

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

Respuesta

Devuelve: PatchPageAPIResponse

Ejemplo

Ejemplo de patchPage

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t pageId = U("page-9876");
auto updatePtr = std::make_shared<UpdateAPIPageData>();
updatePtr->title = utility::string_t(U("About Our Team"));
updatePtr->slug = utility::string_t(U("about-our-team"));
updatePtr->enabled = boost::optional<bool>(true);
updatePtr->description = boost::optional<utility::string_t>(U("Updated team overview and contact information"));
api->patchPage(tenantId, pageId, *updatePtr)
.then([](pplx::task<std::shared_ptr<PatchPageAPIResponse>> t){
    try {
        auto resp = t.get();
        if (resp) {
            std::cout << "Patch successful, page id: " << resp->id << std::endl;
        }
    } catch (const std::exception &e) {
        std::cerr << "Patch failed: " << e.what() << std::endl;
    }
});

Eliminar evento de webhook pendiente

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de deletePendingWebhookEvent

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t eventId = U("wh_evt_456");
boost::optional<utility::string_t> requestId = boost::optional<utility::string_t>(U("req-789"));
api->deletePendingWebhookEvent(tenantId, eventId)
    .then([requestId](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
        try {
            auto resp = t.get();
            if (resp) {
                auto resultCopy = std::make_shared<FlagCommentPublic_200_response>(*resp);
                if (requestId) {
                    (void)requestId.get();
                }
                (void)resultCopy;
            } else {
                auto fallback = std::make_shared<FlagCommentPublic_200_response>();
                (void)fallback;
            }
        } catch (const std::exception&) {
            auto errorObj = std::make_shared<FlagCommentPublic_200_response>();
            (void)errorObj;
        }
    }).wait();

Obtener conteo de eventos de webhook pendientes

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
commentId	string	No
externalId	string	No
eventType	string	No
type	string	No
domain	string	No
attemptCountGT	double	No

Respuesta

Devuelve: GetPendingWebhookEventCount_200_response

Ejemplo

Ejemplo de getPendingWebhookEventCount

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> commentId = boost::optional<utility::string_t>(U("cmt-789"));
boost::optional<utility::string_t> externalId = boost::optional<utility::string_t>(U("ext-456"));
boost::optional<utility::string_t> eventType = boost::optional<utility::string_t>(U("comment_created"));
boost::optional<utility::string_t> type = boost::optional<utility::string_t>(U("webhook"));
boost::optional<utility::string_t> domain = boost::optional<utility::string_t>(U("example.com"));
boost::optional<double> attemptCountGT = boost::optional<double>(1.0);
api->getPendingWebhookEventCount(tenantId, commentId, externalId, eventType, type, domain, attemptCountGT)
.then([](pplx::task<std::shared_ptr<GetPendingWebhookEventCount_200_response>> t){
    try {
        auto resp = t.get();
        auto respCopy = std::make_shared<GetPendingWebhookEventCount_200_response>(*resp);
        std::cout << "Pending webhook event count retrieved\n";
    } catch (const std::exception &e) {
        std::cerr << "Failed to get pending count: " << e.what() << '\n';
    }
}).wait();

Obtener eventos de webhook pendientes

Parámetros

Name	Type	Required
tenantId	string	Sí
commentId	string	No
externalId	string	No
eventType	string	No
type	string	No
domain	string	No
attemptCountGT	double	No
skip	double	No

Response

Devuelve: GetPendingWebhookEvents_200_response

Ejemplo

Ejemplo de getPendingWebhookEvents

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> commentId = boost::optional<utility::string_t>(U("cmt-98765"));
boost::optional<utility::string_t> externalId = boost::optional<utility::string_t>(U("ext-abc-01"));
boost::optional<utility::string_t> eventType = boost::optional<utility::string_t>(U("comment_created"));
boost::optional<utility::string_t> type = boost::optional<utility::string_t>(U("webhook"));
boost::optional<utility::string_t> domain = boost::optional<utility::string_t>(U("example.com"));
boost::optional<double> attemptCountGT = boost::optional<double>(2.0);
boost::optional<double> skip = boost::optional<double>(0.0);
api->getPendingWebhookEvents(tenantId, commentId, externalId, eventType, type, domain, attemptCountGT, skip)
.then([](pplx::task<std::shared_ptr<GetPendingWebhookEvents_200_response>> t) {
    try {
        auto resp = t.get();
        auto copy = std::make_shared<GetPendingWebhookEvents_200_response>(*resp);
        (void)copy;
    } catch (const std::exception& e) {
        (void)e;
        auto empty = std::make_shared<GetPendingWebhookEvents_200_response>();
        (void)empty;
    }
});

Crear configuración de pregunta

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
createQuestionConfigBody	CreateQuestionConfigBody	Sí

Respuesta

Devuelve: CreateQuestionConfig_200_response

Ejemplo

Ejemplo de createQuestionConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateQuestionConfigBody body;
body.name = utility::string_t(U("Feature X Feedback"));
body.description = boost::optional<utility::string_t>(utility::string_t(U("Ask users if Feature X met their needs")));
body.createdBy = utility::string_t(U("admin@mycompany.com"));
body.enabled = boost::optional<bool>(true);
api->createQuestionConfig(tenantId, body).then([](std::shared_ptr<CreateQuestionConfig_200_response> resp){
    if(resp){
        auto result = std::make_shared<CreateQuestionConfig_200_response>(*resp);
        std::wcout << U("Question config created successfully") << std::endl;
    } else {
        std::wcout << U("Failed to create question config") << std::endl;
    }
});

Eliminar configuración de pregunta

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de deleteQuestionConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("qcfg-98765");
boost::optional<utility::string_t> tenantOpt = tenantId;
auto t = api->deleteQuestionConfig(tenantOpt.value_or(utility::string_t()), id)
.then([](std::shared_ptr<FlagCommentPublic_200_response> resp) -> std::shared_ptr<FlagCommentPublic_200_response> {
    auto out = std::make_shared<FlagCommentPublic_200_response>();
    if (resp) *out = *resp;
    return out;
});
t.wait();

Obtener configuración de pregunta

Parámetros

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

Respuesta

Devuelve: GetQuestionConfig_200_response

Ejemplo

Ejemplo de getQuestionConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("question-456");
boost::optional<utility::string_t> locale = U("en-US");
auto defaultResp = std::make_shared<GetQuestionConfig_200_response>();
api->getQuestionConfig(tenantId, id).then([defaultResp](pplx::task<std::shared_ptr<GetQuestionConfig_200_response>> t) {
    try {
        auto resp = t.get();
        if(!resp) resp = defaultResp;
        std::cout << "Question config retrieved" << std::endl;
    } catch(const std::exception &e) {
        std::cerr << "Failed to get question config: " << e.what() << std::endl;
    }
});

Obtener configuraciones de preguntas

Parámetros

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

Respuesta

Devuelve: GetQuestionConfigs_200_response

Ejemplo

Ejemplo de getQuestionConfigs

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = 10;
api->getQuestionConfigs(tenantId, skip).then([](pplx::task<std::shared_ptr<GetQuestionConfigs_200_response>> task) {
    try {
        auto resp = task.get();
        if (resp) {
            auto localCopy = std::make_shared<GetQuestionConfigs_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

Actualizar configuración de pregunta

Parámetros

Name	Type	Required
tenantId	string	Sí
id	string	Sí
updateQuestionConfigBody	UpdateQuestionConfigBody	Sí

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de updateQuestionConfig

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto configId = utility::string_t(U("question-config-456"));
auto body = std::make_shared<UpdateQuestionConfigBody>();
body->enabled = true;
body->threshold = 5;
body->moderatorEmail = utility::string_t(U("moderator@example.com"));
body->notifyUsers = boost::optional<bool>(true);
body->description = boost::optional<utility::string_t>(utility::string_t(U("Tighten question moderation for new users")));
api->updateQuestionConfig(tenantId, configId, *body)
    .then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
        try {
            auto resp = t.get();
            std::cout << (resp ? "updateQuestionConfig succeeded\n" : "updateQuestionConfig returned null\n");
        } catch (const std::exception& e) {
            std::cerr << "updateQuestionConfig failed: " << e.what() << '\n';
        }
    });

Crear resultado de pregunta

Parámetros

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

Respuesta

Devuelve: CreateQuestionResult_200_response

Ejemplo

Ejemplo de createQuestionResult

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateQuestionResultBody createQuestionResultBody;
createQuestionResultBody.questionId = U("question-789");
createQuestionResultBody.userEmail = U("student@example.com");
createQuestionResultBody.selectedOption = U("B");
createQuestionResultBody.isCorrect = true;
createQuestionResultBody.score = 9.5;
createQuestionResultBody.metadata = boost::optional<utility::string_t>(U("{\"session\":\"quiz-2026-01\"}"));
auto task = api->createQuestionResult(tenantId, createQuestionResultBody)
.then([](pplx::task<std::shared_ptr<CreateQuestionResult_200_response>> t){
    try {
        auto result = t.get();
        auto copy = std::make_shared<CreateQuestionResult_200_response>(*result);
        (void)copy;
    } catch (...) {}
});
task.wait();

Eliminar resultado de pregunta

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de deleteQuestionResult

Copy

boost::optional<utility::string_t> maybeTenant = boost::none;
utility::string_t defaultTenant = U("my-tenant-123");
utility::string_t questionId = U("question-456");
utility::string_t tenant = maybeTenant ? *maybeTenant : defaultTenant;
api->deleteQuestionResult(tenant, questionId)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> task){
    try {
        auto resp = task.get();
        auto processed = std::make_shared<FlagCommentPublic_200_response>(*resp);
    } catch (const std::exception&) {
    }
});

Obtener resultado de pregunta

Parámetros

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

Respuesta

Devuelve: GetQuestionResult_200_response

Ejemplo

Ejemplo de getQuestionResult

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t questionId = U("question-456");
boost::optional<utility::string_t> requestor = U("user@example.com");
auto task = api->getQuestionResult(tenantId, questionId)
    .then([requestor](pplx::task<std::shared_ptr<GetQuestionResult_200_response>> prev) -> std::shared_ptr<GetQuestionResult_200_response> {
        try {
            auto resp = prev.get();
            if (!resp) return std::make_shared<GetQuestionResult_200_response>();
            (void)requestor;
            return resp;
        } catch (const std::exception &) {
            return std::make_shared<GetQuestionResult_200_response>();
        }
    });

Obtener resultados de preguntas

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
urlId	string	No
userId	string	No
startDate	string	No
questionId	string	No
questionIds	string	No
skip	double	No

Respuesta

Devuelve: GetQuestionResults_200_response

Ejemplo

Ejemplo de getQuestionResults

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> urlId = boost::optional<utility::string_t>(U("/articles/2025/new-feature"));
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("alice@example.com"));
boost::optional<utility::string_t> startDate = boost::optional<utility::string_t>(U("2025-01-01T00:00:00Z"));
boost::optional<utility::string_t> questionId = boost::optional<utility::string_t>(U("q-789"));
boost::optional<utility::string_t> questionIds = boost::optional<utility::string_t>(U("q-789,q-790"));
boost::optional<double> skip = boost::optional<double>(10.0);
api->getQuestionResults(tenantId, urlId, userId, startDate, questionId, questionIds, skip)
.then([](pplx::task<std::shared_ptr<GetQuestionResults_200_response>> t){
    try {
        std::shared_ptr<GetQuestionResults_200_response> resp = t.get();
        if (resp) {
            auto copy = std::make_shared<GetQuestionResults_200_response>(*resp);
        }
    } catch (const std::exception&) {}
});

Actualizar resultado de pregunta

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de updateQuestionResult

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("question-456");
UpdateQuestionResultBody updateQuestionResultBody;
auto moderatorEmail = std::make_shared<utility::string_t>(U("moderator@example.com"));
boost::optional<utility::string_t> resolutionNote = boost::optional<utility::string_t>(U("Marked duplicate of q-123"));
api->updateQuestionResult(tenantId, id, updateQuestionResultBody)
    .then([moderatorEmail, resolutionNote](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t)
    {
        try {
            auto resp = t.get();
            if (resp) {
                auto resultPtr = resp;
            }
        } catch (...) {}
    });

Agregación de resultados de preguntas

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
questionId	string	No
questionIds	vector<string	No
urlId	string	No
timeBucket	AggregateTimeBucket	No
startDate	datetime	No
forceRecalculate	bool	No

Respuesta

Devuelve: AggregateQuestionResults_200_response

Ejemplo

Ejemplo de aggregateQuestionResults

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> questionId(U("q-42"));
boost::optional<std::vector<utility::string_t>> questionIds(std::vector<utility::string_t>{U("q-42"), U("q-43")});
boost::optional<utility::string_t> urlId(U("page-789"));
boost::optional<AggregateTimeBucket> timeBucket;
boost::optional<utility::datetime> startDate(utility::datetime::from_string(U("2025-01-01T00:00:00Z")));
boost::optional<bool> forceRecalculate(true);
api->aggregateQuestionResults(tenantId, questionId, questionIds, urlId, timeBucket, startDate, forceRecalculate)
.then([](std::shared_ptr<AggregateQuestionResults_200_response> resp){
    if (resp) {
        auto resultCopy = std::make_shared<AggregateQuestionResults_200_response>(*resp);
    }
});

Agregación masiva de resultados de preguntas

Parámetros

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

Respuesta

Devuelve: BulkAggregateQuestionResults_200_response

Ejemplo

Ejemplo de bulkAggregateQuestionResults

Copy

utility::string_t tenantId = U("my-tenant-123");
BulkAggregateQuestionResultsRequest request;
boost::optional<bool> forceRecalculate(true);
api->bulkAggregateQuestionResults(tenantId, request, forceRecalculate)
.then([](pplx::task<std::shared_ptr<BulkAggregateQuestionResults_200_response>> t){
    try {
        auto resp = t.get();
        if (!resp) {
            auto empty = std::make_shared<BulkAggregateQuestionResults_200_response>();
            std::cout << "No aggregated results returned\n";
        } else {
            std::cout << "Aggregated results received\n";
        }
    } catch (const std::exception& ex) {
        std::cerr << "Error fetching aggregated results: " << ex.what() << '\n';
    }
});

Combinar comentarios con resultados de preguntas

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
questionId	string	No
questionIds	vector<string	No
urlId	string	No
startDate	datetime	No
forceRecalculate	bool	No
minValue	double	No
maxValue	double	No
limit	double	No

Respuesta

Devuelve: CombineCommentsWithQuestionResults_200_response

Ejemplo

Ejemplo de combineCommentsWithQuestionResults

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> questionId = boost::optional<utility::string_t>(U("q-98765"));
boost::optional<std::vector<utility::string_t>> questionIds = boost::optional<std::vector<utility::string_t>>(std::vector<utility::string_t>{U("q-98765"), U("q-12345")});
boost::optional<utility::string_t> urlId = boost::optional<utility::string_t>(U("/posts/2024/interesting-article"));
boost::optional<utility::datetime> startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2024-01-01T00:00:00Z")));
boost::optional<bool> forceRecalculate = boost::optional<bool>(true);
boost::optional<double> minValue = boost::optional<double>(0.0);
boost::optional<double> maxValue = boost::optional<double>(1.0);
boost::optional<double> limit = boost::optional<double>(100.0);
api->combineCommentsWithQuestionResults(tenantId, questionId, questionIds, urlId, startDate, forceRecalculate, minValue, maxValue, limit)
.then([](pplx::task<std::shared_ptr<CombineCommentsWithQuestionResults_200_response>> task){
    try {
        auto response = task.get();
        auto output = response ? response : std::make_shared<CombineCommentsWithQuestionResults_200_response>();
    } catch (const std::exception&) {
    }
});

Agregar usuario SSO

Parámetros

Nombre	Tipo	Requerido	Descripción
tenantId	string	Sí
createAPISSOUserData	CreateAPISSOUserData	Sí

Respuesta

Devuelve: AddSSOUserAPIResponse

Ejemplo

Ejemplo de addSSOUser

Copy

utility::string_t tenantId = U("my-tenant-123");
auto createData = std::make_shared<CreateAPISSOUserData>();
createData->email = utility::string_t(U("alice@example.com"));
createData->externalUserId = utility::string_t(U("okta|987654321"));
createData->displayName = boost::optional<utility::string_t>(U("Alice Johnson"));
createData->roles = std::vector<utility::string_t>{ U("moderator"), U("editor") };
api->addSSOUser(tenantId, createData)
.then([](pplx::task<std::shared_ptr<AddSSOUserAPIResponse>> task){
    try {
        auto resp = task.get();
        if (resp) {
            (void)resp;
        }
    } catch (...) {
    }
});

Eliminar usuario SSO

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
id	string	Sí
deleteComments	bool	No
commentDeleteMode	string	No

Respuesta

Devuelve: DeleteSSOUserAPIResponse

Ejemplo

Ejemplo de deleteSSOUser

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t ssoId = U("user@example.com");
boost::optional<bool> deleteComments = true;
boost::optional<utility::string_t> commentDeleteMode = U("anonymize");
api->deleteSSOUser(tenantId, ssoId, deleteComments, commentDeleteMode)
.then([](pplx::task<std::shared_ptr<DeleteSSOUserAPIResponse>> t){
    try {
        auto resp = t.get();
        auto respCopy = std::make_shared<DeleteSSOUserAPIResponse>(*resp);
        (void)respCopy;
    } catch (const std::exception&) {
    }
});

Obtener usuario SSO por correo

Parámetros

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

Respuesta

Devuelve: GetSSOUserByEmailAPIResponse

Ejemplo

Ejemplo de getSSOUserByEmail

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t email = U("user@example.com");
boost::optional<utility::string_t> includeInactive = boost::optional<utility::string_t>(U("false"));
api->getSSOUserByEmail(tenantId, email).then([includeInactive](pplx::task<std::shared_ptr<GetSSOUserByEmailAPIResponse>> t) {
    try {
        auto resp = t.get();
        return resp ? resp : std::make_shared<GetSSOUserByEmailAPIResponse>();
    } catch (...) {
        return std::make_shared<GetSSOUserByEmailAPIResponse>();
    }
}).then([](std::shared_ptr<GetSSOUserByEmailAPIResponse> finalResp) {
    (void)finalResp;
});

Obtener usuario SSO por ID

Parámetros

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

Respuesta

Devuelve: GetSSOUserByIdAPIResponse

Ejemplo

Ejemplo de getSSOUserById

Copy

boost::optional<utility::string_t> optId = U("user-42@example.com");
utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = optId.value_or(U("user-42@example.com"));
api->getSSOUserById(tenantId, id).then([](pplx::task<std::shared_ptr<GetSSOUserByIdAPIResponse>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto out = resp;
            (void)out;
        } else {
            auto fallback = std::make_shared<GetSSOUserByIdAPIResponse>();
            (void)fallback;
        }
    } catch (const std::exception& ex) {
        auto fallback = std::make_shared<GetSSOUserByIdAPIResponse>();
        (void)ex;
        (void)fallback;
    }
});

Obtener usuarios SSO

Parámetros

Name	Type	Required	Description
tenantId	string	Sí
skip	int32_t	No

Respuesta

Devuelve: GetSSOUsers_200_response

Ejemplo

Ejemplo de getSSOUsers

Copy

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

Modificar parcialmente usuario SSO

Parámetros

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

Respuesta

Devuelve: PatchSSOUserAPIResponse

Ejemplo

Ejemplo de patchSSOUser

Copy

UpdateAPISSOUserData updateData;
updateData.email = utility::string_t(U"user@example.com");
updateData.displayName = utility::string_t(U"Jane Doe");
boost::optional<bool> updateComments = true;
auto responseHolder = std::make_shared<PatchSSOUserAPIResponse>();
api->patchSSOUser(utility::string_t(U"my-tenant-123"), utility::string_t(U"user@example.com"), updateData, updateComments)
.then([responseHolder](std::shared_ptr<PatchSSOUserAPIResponse> resp){
    if (resp) *responseHolder = *resp;
    return responseHolder;
});

Reemplazar usuario SSO

Parámetros

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

Respuesta

Devuelve: PutSSOUserAPIResponse

Ejemplo

Ejemplo de putSSOUser

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("user@example.com");
UpdateAPISSOUserData updateData;
updateData.displayName = U("Jane Doe");
updateData.email = U("user@example.com");
boost::optional<bool> updateComments = true;
api->putSSOUser(tenantId, id, updateData, updateComments)
.then([](std::shared_ptr<PutSSOUserAPIResponse> resp){
    if(!resp){ std::cout << "putSSOUser returned null\n"; return; }
    auto copy = std::make_shared<PutSSOUserAPIResponse>(*resp);
    std::cout << "SSO user updated successfully\n";
});

Crear suscripción

Parámetros

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

Respuesta

Devuelve: CreateSubscriptionAPIResponse

Ejemplo

Ejemplo de createSubscription

Copy

utility::string_t tenantId = U("my-tenant-123");
auto payload = std::make_shared<CreateAPIUserSubscriptionData>();
payload->userEmail = U("user@example.com");
payload->planId = U("pro-monthly");
payload->couponCode = boost::optional<utility::string_t>(U("WELCOME10"));
payload->trialDays = boost::optional<int>(14);
payload->autoRenew = boost::optional<bool>(true);
api->createSubscription(tenantId, *payload).then([](std::shared_ptr<CreateSubscriptionAPIResponse> resp) {
    if (resp) std::cout << "Subscription created successfully" << std::endl;
    else std::cout << "Failed to create subscription" << std::endl;
});

Eliminar suscripción

Parámetros

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

Respuesta

Devuelve: DeleteSubscriptionAPIResponse

Ejemplo

Ejemplo de deleteSubscription

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("subscription-987");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
auto defaultResp = std::make_shared<DeleteSubscriptionAPIResponse>();
api->deleteSubscription(tenantId, id, userId)
.then([defaultResp](pplx::task<std::shared_ptr<DeleteSubscriptionAPIResponse>> t){
    try {
        auto resp = t.get();
        if (!resp) resp = defaultResp;
        std::cout << "Delete completed\n";
    } catch (const std::exception &e) {
        std::cerr << "Delete failed: " << e.what() << '\n';
    }
});

Obtener suscripciones

Parámetros

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

Respuesta

Devuelve: GetSubscriptionsAPIResponse

Ejemplo

Ejemplo de getSubscriptions

Copy

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

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

utility::string_t tenantId = U("my-tenant-123");
utility::string_t subscriptionId = U("sub-456");
UpdateAPIUserSubscriptionData updateData{};
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user-789"));
api->updateSubscription(tenantId, subscriptionId, updateData, userId)
.then([](pplx::task<std::shared_ptr<UpdateSubscriptionAPIResponse>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<UpdateSubscriptionAPIResponse>(*resp);
        }
    } catch (const std::exception&) {}
}).wait();

Obtener usos diarios del inquilino

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
yearNumber	double	No
monthNumber	double	No
dayNumber	double	No
skip	double	No

Respuesta

Devuelve: GetTenantDailyUsages_200_response

Ejemplo

Ejemplo de getTenantDailyUsages

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> year = 2025;
boost::optional<double> month = 1;
auto placeholder = std::make_shared<GetTenantDailyUsages_200_response>();
api->getTenantDailyUsages(tenantId, year, month, boost::optional<double>(), boost::optional<double>())
.then([](pplx::task<std::shared_ptr<GetTenantDailyUsages_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) std::cout << "Received tenant daily usages\n";
        else std::cout << "No usage data\n";
    } catch (const std::exception &e) {
        std::cout << "Request error: " << e.what() << '\n';
    }
});

Crear paquete del inquilino

Parámetros

Name	Type	Required	Description
tenantId	string	Sí
createTenantPackageBody	CreateTenantPackageBody	Sí

Respuesta

Devuelve: CreateTenantPackage_200_response

Ejemplo

Ejemplo de createTenantPackage

Copy

utility::string_t tenantId = U("my-tenant-123");
auto body = std::make_shared<CreateTenantPackageBody>();
body->name = U("Standard Package - 1k comments");
body->createdByEmail = U("admin@mycompany.com");
body->monthlyLimit = boost::optional<int>(1000);
body->notes = boost::optional<utility::string_t>(U("Onboarding promo"));
api->createTenantPackage(tenantId, *body)
.then([](pplx::task<std::shared_ptr<CreateTenantPackage_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            std::cout << "Package created: " << utility::conversions::to_utf8string(resp->packageId) << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << "Create failed: " << e.what() << std::endl;
    }
});

Eliminar paquete del inquilino

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de deleteTenantPackage

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t pkgId = U("package-456");
boost::optional<utility::string_t> ifMatch = boost::optional<utility::string_t>(U("\"etag-789\""));
auto fallback = std::make_shared<FlagCommentPublic_200_response>();
auto task = api->deleteTenantPackage(tenantId, pkgId).then([fallback](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) return resp;
        return fallback;
    } catch (const std::exception&) {
        return fallback;
    }
});
task.wait();

Obtener paquete del inquilino

Parámetros

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

Respuesta

Devuelve: GetTenantPackage_200_response

Ejemplo

Ejemplo de getTenantPackage

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t packageId = U("pkg-456");
boost::optional<utility::string_t> requestTrace = U("trace-20260112-01");
api->getTenantPackage(tenantId, packageId)
.then([requestTrace](std::shared_ptr<GetTenantPackage_200_response> resp){
    auto result = resp ? resp : std::make_shared<GetTenantPackage_200_response>();
    if (requestTrace) { auto trace = *requestTrace; (void)trace; }
    return result;
})
.then([](std::shared_ptr<GetTenantPackage_200_response> finalResp){
    (void)finalResp;
});

Obtener paquetes del inquilino

Parámetros

Name	Type	Required	Description
tenantId	string	Sí
skip	double	No

Respuesta

Devuelve: GetTenantPackages_200_response

Ejemplo

Ejemplo de getTenantPackages

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = 10.0;
auto task = api->getTenantPackages(tenantId, skip).then([](pplx::task<std::shared_ptr<GetTenantPackages_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            (void)resp;
        }
    } catch (const std::exception&) {
        auto fallback = std::make_shared<GetTenantPackages_200_response>();
        (void)fallback;
    }
});

Reemplazar paquete del inquilino

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de replaceTenantPackage

Copy

utility::string_t tenantId = utility::string_t("my-tenant-123");
utility::string_t packageId = utility::string_t("pkg-456");
ReplaceTenantPackageBody body;
body.name = utility::string_t("Premium Plan");
body.planId = utility::string_t("premium_monthly");
body.seats = 25;
body.billingEmail = utility::string_t("billing@acme.com");
boost::optional<utility::string_t> notes = boost::optional<utility::string_t>(utility::string_t("Migrated subscription"));
body.notes = notes;
api->replaceTenantPackage(tenantId, packageId, body).then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> task){
    try{
        auto resp = task.get();
        if(resp){
            auto resultCopy = std::make_shared<FlagCommentPublic_200_response>(*resp);
        }
    } catch(const std::exception&){
    }
});

Actualizar paquete del inquilino

Parámetros

Name	Type	Obligatorio
tenantId	string	Sí
id	string	Sí
updateTenantPackageBody	UpdateTenantPackageBody	Sí

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de updateTenantPackage

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t packageId = U("pkg-456");
auto bodyPtr = std::make_shared<UpdateTenantPackageBody>();
bodyPtr->name = utility::string_t(U("Pro Monthly"));
bodyPtr->description = boost::optional<utility::string_t>(U("Monthly subscription for pro users"));
bodyPtr->enabled = boost::optional<bool>(true);
api->updateTenantPackage(tenantId, packageId, *bodyPtr)
.then([](std::shared_ptr<FlagCommentPublic_200_response> resp){
    std::cout << (resp ? "updateTenantPackage succeeded\n" : "updateTenantPackage returned null\n");
});

Crear usuario del inquilino

Parámetros

Name	Type	Required	Description
tenantId	string	Sí
createTenantUserBody	CreateTenantUserBody	Sí

Respuesta

Devuelve: CreateTenantUser_200_response

Ejemplo

Ejemplo de createTenantUser

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
CreateTenantUserBody createTenantUserBody;
createTenantUserBody.email = utility::conversions::to_string_t("new.user@company.com");
createTenantUserBody.displayName = boost::optional<utility::string_t>(utility::conversions::to_string_t("New User"));
api->createTenantUser(tenantId, createTenantUserBody)
    .then([](pplx::task<std::shared_ptr<CreateTenantUser_200_response>> task){
        try {
            auto resp = task.get();
            auto created = std::make_shared<CreateTenantUser_200_response>(*resp);
        } catch (const std::exception&) {
        }
    });

Eliminar usuario del inquilino

Parámetros

Name	Type	Required
tenantId	string	Sí
id	string	Sí
deleteComments	string	No
commentDeleteMode	string	No

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de deleteTenantUser

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user@example.com");
boost::optional<utility::string_t> deleteComments = boost::optional<utility::string_t>(U("true"));
boost::optional<utility::string_t> commentDeleteMode = boost::optional<utility::string_t>(U("soft"));
auto fallback = std::make_shared<FlagCommentPublic_200_response>();
api->deleteTenantUser(tenantId, userId, deleteComments, commentDeleteMode)
.then([fallback](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
    try {
        auto resp = t.get();
        if (!resp) resp = fallback;
        std::cout << "deleteTenantUser completed\n";
    } catch (const std::exception &e) {
        std::cout << "deleteTenantUser failed: " << e.what() << "\n";
    }
}).wait();

Obtener usuario del inquilino

Parámetros

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

Respuesta

Devuelve: GetTenantUser_200_response

Ejemplo

Ejemplo de getTenantUser

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("alice@example.com");
boost::optional<utility::string_t> includeMetadata = boost::optional<utility::string_t>(U("true"));
api->getTenantUser(tenantId, userId).then([includeMetadata](pplx::task<std::shared_ptr<GetTenantUser_200_response>> t)
{
    try {
        auto resp = t.get();
        auto result = resp ? resp : std::make_shared<GetTenantUser_200_response>();
        if (includeMetadata && result) { (void)includeMetadata; }
        (void)result;
    } catch (const std::exception& e) {
        auto fallback = std::make_shared<GetTenantUser_200_response>();
        (void)fallback;
    }
});

Obtener usuarios del inquilino

Parámetros

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

Respuesta

Devuelve: GetTenantUsers_200_response

Ejemplo

Ejemplo de getTenantUsers

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = boost::optional<double>(20);
api->getTenantUsers(tenantId, skip)
    .then([=](pplx::task<std::shared_ptr<GetTenantUsers_200_response>> t) {
        try {
            std::shared_ptr<GetTenantUsers_200_response> resp = t.get();
            if (!resp) resp = std::make_shared<GetTenantUsers_200_response>();
            (void)resp;
        } catch (const std::exception& ex) {
            (void)ex;
            std::shared_ptr<GetTenantUsers_200_response> err = std::make_shared<GetTenantUsers_200_response>();
        }
    });

Reemplazar usuario del inquilino

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
replaceTenantUserBody	ReplaceTenantUserBody	Sí
updateComments	string	No

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de replaceTenantUser

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("user@example.com");
ReplaceTenantUserBody replaceBody;
boost::optional<utility::string_t> updateComments = boost::optional<utility::string_t>(U("true"));
api->replaceTenantUser(tenantId, id, replaceBody, updateComments)
.then([](std::shared_ptr<FlagCommentPublic_200_response> resp){
    if (resp) {
        auto copy = std::make_shared<FlagCommentPublic_200_response>(*resp);
    }
});

Enviar enlace de inicio de sesión

Parámetros

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

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de sendLoginLink

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user@example.com");
boost::optional<utility::string_t> redirectURL = utility::string_t(U("https://app.example.com/welcome"));
api->sendLoginLink(tenantId, userId, redirectURL)
    .then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t)
    {
        try
        {
            auto resp = t.get();
            if (resp) return resp;
            return std::make_shared<FlagCommentPublic_200_response>();
        }
        catch (...)
        {
            return std::make_shared<FlagCommentPublic_200_response>();
        }
    });

Actualizar usuario del inquilino

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
id	string	Sí
updateTenantUserBody	UpdateTenantUserBody	Sí
updateComments	string	No

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de updateTenantUser

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("jane.doe@example.com");
auto bodyPtr = std::make_shared<UpdateTenantUserBody>();
bodyPtr->setEmail(U("jane.doe@example.com"));
bodyPtr->setDisplayName(U("Jane Doe"));
boost::optional<utility::string_t> updateComments = U("Normalized display name");
api->updateTenantUser(tenantId, userId, *bodyPtr, updateComments)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) std::cout << "Tenant user updated successfully\n";
        else std::cout << "Update returned no data\n";
    } catch (const std::exception& ex) {
        std::cerr << "Update failed: " << ex.what() << '\n';
    }
});

Crear inquilino

Parámetros

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

Respuesta

Devuelve: CreateTenant_200_response

Ejemplo

Ejemplo de createTenant

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateTenantBody createTenantBody;
createTenantBody.displayName = U("My Tenant Inc");
createTenantBody.adminEmail = U("admin@mytenant.com");
createTenantBody.plan = boost::optional<utility::string_t>(U("pro"));
auto task = api->createTenant(tenantId, createTenantBody)
    .then([](std::shared_ptr<CreateTenant_200_response> resp){
        if (resp){
            auto createdId = std::make_shared<utility::string_t>(resp->tenantId);
        }
    });
task.wait();

Eliminar inquilino

Parámetros

Name	Type	Required
tenantId	string	Sí
id	string	Sí
sure	string	No

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de deleteTenant

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("flag-456");
boost::optional<utility::string_t> sure = utility::string_t(U("true"));
api->deleteTenant(tenantId, id, sure)
    .then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
        try {
            auto resp = t.get();
            auto safeResp = resp ? resp : std::make_shared<FlagCommentPublic_200_response>();
            (void)safeResp;
        } catch (...) {}
    });

Obtener inquilino

Parámetros

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

Respuesta

Devuelve: GetTenant_200_response

Ejemplo

Ejemplo de getTenant

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("admin@fastcomments.com");
boost::optional<utility::string_t> asOf = boost::optional<utility::string_t>(U("2026-01-01T00:00:00Z"));
api->getTenant(tenantId, id).then([asOf](pplx::task<std::shared_ptr<GetTenant_200_response>> t) {
    try {
        auto resp = t.get();
        if (!resp) return;
        auto processed = std::make_shared<GetTenant_200_response>(*resp);
    } catch (const std::exception&) {
    }
});

Obtener inquilinos

Parámetros

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

Respuesta

Devuelve: GetTenants_200_response

Ejemplo

Ejemplo de getTenants

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> meta = boost::optional<utility::string_t>(U("admin@example.com"));
boost::optional<double> skip = boost::optional<double>(10.0);
auto task = api->getTenants(tenantId, meta, skip)
    .then([](std::shared_ptr<GetTenants_200_response> resp){
        if (resp) {
            auto copy = std::make_shared<GetTenants_200_response>(*resp);
        }
    });

Actualizar inquilino

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
id	string	Sí
updateTenantBody	UpdateTenantBody	Sí

Respuesta

Devuelve: FlagCommentPublic_200_response

Ejemplo

Ejemplo de updateTenant

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto id = utility::string_t(U("tenant-0001"));
auto bodyPtr = std::make_shared<UpdateTenantBody>();
bodyPtr->setDisplayName(utility::string_t(U("Acme Corporation")));
bodyPtr->setAdminEmail(utility::string_t(U("admin@acme.com")));
bodyPtr->setIsActive(true);
bodyPtr->setMaxUsers(boost::optional<int>(250));
api->updateTenant(tenantId, id, *bodyPtr)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto msg = resp->getMessage();
            std::wcout << msg << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
});

Cambiar estado del ticket

Parámetros

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

Respuesta

Devuelve: ChangeTicketState_200_response

Ejemplo

Ejemplo de changeTicketState

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("agent@example.com");
utility::string_t id = U("TICKET-456");
auto changeBody = std::make_shared<ChangeTicketStateBody>();
changeBody->state = U("resolved");
changeBody->comment = U("Resolved as duplicate after review");
changeBody->notify = boost::optional<bool>(true);
api->changeTicketState(tenantId, userId, id, *changeBody)
.then([](pplx::task<std::shared_ptr<ChangeTicketState_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<ChangeTicketState_200_response>(*resp);
        }
    } catch (const std::exception&) {}
});

Crear ticket

Parámetros

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

Respuesta

Devuelve: CreateTicket_200_response

Ejemplo

Ejemplo de createTicket

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user@example.com");
auto bodyPtr = std::make_shared<CreateTicketBody>();
bodyPtr->subject = U("Comments not posting on article");
bodyPtr->message = U("Submitting a comment returns 200 but it does not appear for other users");
bodyPtr->priority = boost::optional<utility::string_t>(U("low"));
api->createTicket(tenantId, userId, *bodyPtr)
.then([](pplx::task<std::shared_ptr<CreateTicket_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto created = resp;
        }
    } catch (const std::exception& e) {
        (void)e;
    }
});

Obtener ticket

Parámetros

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

Respuesta

Devuelve: GetTicket_200_response

Ejemplo

Ejemplo de getTicket

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t ticketId = U("ticket-456");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
api->getTicket(tenantId, ticketId, userId)
.then([](pplx::task<std::shared_ptr<GetTicket_200_response>> t) {
    try {
        auto resp = t.get();
        auto wrapped = std::make_shared<std::shared_ptr<GetTicket_200_response>>(resp);
        if (*wrapped) {
            std::cout << "Ticket retrieved\n";
        } else {
            std::cout << "No ticket\n";
        }
    } catch (const std::exception &e) {
        std::cerr << "Error: " << e.what() << '\n';
    }
});

Obtener tickets

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
userId	string	No
state	double	No
skip	double	No
limit	double	No

Respuesta

Devuelve: GetTickets_200_response

Ejemplo

Ejemplo de getTickets

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<double> state = boost::optional<double>(1.0);
boost::optional<double> skip = boost::optional<double>(0.0);
boost::optional<double> limit = boost::optional<double>(50.0);
api->getTickets(tenantId, userId, state, skip, limit)
.then([](pplx::task<std::shared_ptr<GetTickets_200_response>> t){
    try {
        auto resp = t.get();
        auto copy = std::make_shared<GetTickets_200_response>(*resp);
        std::cout << "Retrieved tickets: " << (resp ? "non-null" : "null") << std::endl;
    } catch (const std::exception &e) {
        std::cerr << "getTickets failed: " << e.what() << std::endl;
    }
});

Subir imagen

Subir y redimensionar una imagen

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
file	HttpContent	Sí
sizePreset	SizePreset	No
urlId	string	No

Respuesta

Devuelve: UploadImageResponse

Ejemplo

Ejemplo de uploadImage

Copy

utility::string_t tenantId = U("my-tenant-123");
auto fileBytes = std::vector<unsigned char>{0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A};
auto file = std::make_shared<HttpContent>(fileBytes, U("image/png"), U("avatar.png"));
boost::optional<SizePreset> sizePreset = boost::optional<SizePreset>(SizePreset::MEDIUM);
boost::optional<utility::string_t> urlId = boost::optional<utility::string_t>(U("user-avatar-987"));
api->uploadImage(tenantId, file, sizePreset, urlId)
    .then([](pplx::task<std::shared_ptr<UploadImageResponse>> task) {
        try {
            return task.get();
        } catch (...) {
            return std::shared_ptr<UploadImageResponse>();
        }
    });

Obtener progreso de insignia por ID

Parámetros

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

Respuesta

Devuelve: GetUserBadgeProgressById_200_response

Ejemplo

Ejemplo de getUserBadgeProgressById

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("badge-abc-456");
boost::optional<utility::string_t> preferredLocale = boost::optional<utility::string_t>(U("en-US"));
api->getUserBadgeProgressById(tenantId, id)
.then([=](std::shared_ptr<GetUserBadgeProgressById_200_response> resp){
    if(!resp) return;
    auto copy = std::make_shared<GetUserBadgeProgressById_200_response>(*resp);
    (void)copy;
});

Obtener progreso de insignia por ID de usuario

Parámetros

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

Respuesta

Devuelve: GetUserBadgeProgressById_200_response

Ejemplo

Ejemplo de getUserBadgeProgressByUserId

Copy

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

Obtener lista de progreso de insignias

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
userId	string	No
limit	double	No
skip	double	No

Respuesta

Devuelve: GetUserBadgeProgressList_200_response

Ejemplo

Ejemplo de getUserBadgeProgressList

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<double> limit = boost::optional<double>(50);
boost::optional<double> skip = boost::optional<double>(0);
api->getUserBadgeProgressList(tenantId, userId, limit, skip)
.then([](pplx::task<std::shared_ptr<GetUserBadgeProgressList_200_response>> t){
    try {
        auto resp = t.get();
        auto copied = std::make_shared<GetUserBadgeProgressList_200_response>(*resp);
        std::cout << "Badge progress entries received\n";
    } catch (const std::exception &e) {
        std::cerr << "Failed to get badge progress: " << e.what() << '\n';
    }
});

Crear insignia de usuario

Parámetros

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

Respuesta

Devuelve: CreateUserBadge_200_response

Ejemplo

Ejemplo de createUserBadge

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateUserBadgeParams params;
params.userId = U("user@example.com");
params.badgeId = U("trusted-contributor");
params.note = boost::optional<utility::string_t>(U("Awarded for outstanding moderation"));
api->createUserBadge(tenantId, params)
.then([](std::shared_ptr<CreateUserBadge_200_response> resp){
    if (resp) {
        auto copied = std::make_shared<CreateUserBadge_200_response>(*resp);
    }
})
.wait();

Eliminar insignia de usuario

Parámetros

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Respuesta

Devuelve: UpdateUserBadge_200_response

Ejemplo

Ejemplo de deleteUserBadge

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
utility::string_t badgeId = utility::conversions::to_string_t("badge-456");
boost::optional<utility::string_t> traceId = boost::none;
api->deleteUserBadge(tenantId, badgeId)
.then([traceId](pplx::task<std::shared_ptr<UpdateUserBadge_200_response>> t) {
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<UpdateUserBadge_200_response>();
        return resp;
    } catch (const std::exception&) {
        return std::shared_ptr<UpdateUserBadge_200_response>();
    }
});

Obtener insignia de usuario

Parámetros

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

Respuesta

Devuelve: GetUserBadge_200_response

Ejemplo

Ejemplo de getUserBadge

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("user@example.com");
boost::optional<utility::string_t> traceId = U("trace-456");
api->getUserBadge(tenantId, id).then([traceId](std::shared_ptr<GetUserBadge_200_response> resp) {
    if (!resp) resp = std::make_shared<GetUserBadge_200_response>();
    utility::string_t activeTrace = traceId.value_or(U(""));
    (void)activeTrace;
    return resp;
});

Obtener insignias de usuario

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
userId	string	No
badgeId	string	No
type	double	No
displayedOnComments	bool	No
limit	double	No
skip	double	No

Respuesta

Devuelve: GetUserBadges_200_response

Ejemplo

Ejemplo de getUserBadges

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> userId(utility::conversions::to_string_t("user@example.com"));
boost::optional<utility::string_t> badgeId(utility::conversions::to_string_t("badge-elite"));
boost::optional<double> type(1.0);
boost::optional<bool> displayedOnComments(true);
boost::optional<double> limit(50.0);
boost::optional<double> skip(0.0);
auto resultHolder = std::make_shared<GetUserBadges_200_response>();
api->getUserBadges(tenantId, userId, badgeId, type, displayedOnComments, limit, skip)
.then([&resultHolder](std::shared_ptr<GetUserBadges_200_response> resp){
    if (resp) resultHolder = resp;
    return resultHolder;
});

Actualizar insignia de usuario

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
id	string	Sí
updateUserBadgeParams	UpdateUserBadgeParams	Sí

Respuesta

Devuelve: UpdateUserBadge_200_response

Ejemplo

Ejemplo de updateUserBadge

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("user@example.com");
UpdateUserBadgeParams updateParams;
updateParams.badgeId = U("badge-top-100");
updateParams.label = U("Top Contributor");
updateParams.active = boost::optional<bool>(true);
updateParams.expiresAt = boost::optional<utility::string_t>(U("2026-12-31T23:59:59Z"));
api->updateUserBadge(tenantId, id, updateParams)
.then([](pplx::task<std::shared_ptr<UpdateUserBadge_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto result = std::make_shared<UpdateUserBadge_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

Obtener conteo de notificaciones del usuario

Parámetros

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

Respuesta

Devuelve: GetUserNotificationCount_200_response

Ejemplo

Ejemplo de getUserNotificationCount

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
std::shared_ptr<GetUserNotificationCount_200_response> result;
api->getUserNotificationCount(tenantId, sso)
.then([&result](pplx::task<std::shared_ptr<GetUserNotificationCount_200_response>> t) {
    try {
        result = t.get();
        if (!result) result = std::make_shared<GetUserNotificationCount_200_response>();
    } catch (...) {
        result = std::make_shared<GetUserNotificationCount_200_response>();
    }
}).wait();

Obtener notificaciones del usuario

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Yes
pageSize	int32_t	No
afterId	string	No
includeContext	bool	No
afterCreatedAt	int64_t	No
unreadOnly	bool	No
dmOnly	bool	No
noDm	bool	No
includeTranslations	bool	No
sso	string	No

Respuesta

Devuelve: GetUserNotifications_200_response

Ejemplo

Ejemplo de getUserNotifications

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<int32_t> pageSize = 50;
boost::optional<utility::string_t> afterId = utility::conversions::to_string_t("notif_98765");
boost::optional<bool> includeContext = true;
boost::optional<int64_t> afterCreatedAt = static_cast<int64_t>(1672531200);
boost::optional<bool> unreadOnly = true;
boost::optional<bool> dmOnly = false;
boost::optional<bool> noDm = false;
boost::optional<bool> includeTranslations = true;
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("user@example.com");
api->getUserNotifications(tenantId, pageSize, afterId, includeContext, afterCreatedAt, unreadOnly, dmOnly, noDm, includeTranslations, sso)
.then([](pplx::task<std::shared_ptr<GetUserNotifications_200_response>> task){
    try {
        auto resp = task.get();
        auto copy = std::make_shared<GetUserNotifications_200_response>(*resp);
        return copy;
    } catch (...) {
        return std::shared_ptr<GetUserNotifications_200_response>();
    }
});

Restablecer conteo de notificaciones del usuario

Parámetros

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

Respuesta

Devuelve: ResetUserNotifications_200_response

Ejemplo

Ejemplo de resetUserNotificationCount

Copy

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

Restablecer notificaciones del usuario

Parámetros

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

Respuesta

Devuelve: ResetUserNotifications_200_response

Ejemplo

Ejemplo de resetUserNotifications

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> afterId = boost::optional<utility::string_t>(U("notif-987654321"));
boost::optional<int64_t> afterCreatedAt = boost::optional<int64_t>(1625097600000LL);
boost::optional<bool> unreadOnly = boost::optional<bool>(true);
boost::optional<bool> dmOnly = boost::optional<bool>(false);
boost::optional<bool> noDm;
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
api->resetUserNotifications(tenantId, afterId, afterCreatedAt, unreadOnly, dmOnly, noDm, sso)
    .then([](pplx::task<std::shared_ptr<ResetUserNotifications_200_response>> t)
    {
        try
        {
            auto resp = t.get();
            auto respCopy = std::make_shared<ResetUserNotifications_200_response>(*resp);
            return respCopy;
        }
        catch (...)
        {
            return std::shared_ptr<ResetUserNotifications_200_response>();
        }
    });

Actualizar estado de suscripción a notificaciones de comentarios del usuario

Habilitar o deshabilitar notificaciones para un comentario específico.

Parámetros

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

Respuesta

Devuelve: UpdateUserNotificationStatus_200_response

Ejemplo

Ejemplo de updateUserNotificationCommentSubscriptionStatus

Copy

utility::string_t tenantId = utility::string_t(U("my-tenant-123"));
utility::string_t notificationId = utility::string_t(U("notif-789"));
utility::string_t optedInOrOut = utility::string_t(U("opted_in"));
utility::string_t commentId = utility::string_t(U("cmt-456"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(utility::string_t(U("user@example.com")));
api->updateUserNotificationCommentSubscriptionStatus(tenantId, notificationId, optedInOrOut, commentId, sso)
.then([](pplx::task<std::shared_ptr<UpdateUserNotificationStatus_200_response>> t){
    try {
        auto resp = t.get();
        auto result = resp ? resp : std::make_shared<UpdateUserNotificationStatus_200_response>();
    } catch (const std::exception&) {}
});

Actualizar estado de suscripción a notificaciones de página del usuario

Habilita o deshabilita las 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

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
urlId	string	Sí
url	string	Sí
pageTitle	string	Sí
subscribedOrUnsubscribed	string	Sí
sso	string	No

Respuesta

Devuelve: UpdateUserNotificationStatus_200_response

Ejemplo

Ejemplo de updateUserNotificationPageSubscriptionStatus

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("page-456");
utility::string_t url = U("https://www.example.com/articles/2026/new-feature");
utility::string_t pageTitle = U("New Feature Announcement");
utility::string_t subscribedOrUnsubscribed = U("subscribed");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
auto placeholder = std::make_shared<UpdateUserNotificationStatus_200_response>();
api->updateUserNotificationPageSubscriptionStatus(tenantId, urlId, url, pageTitle, subscribedOrUnsubscribed, sso)
.then([](pplx::task<std::shared_ptr<UpdateUserNotificationStatus_200_response>> task){
    try {
        auto resp = task.get();
        (void)resp;
    } catch (const std::exception &e) {
        (void)e;
    }
});

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: UpdateUserNotificationStatus_200_response

Ejemplo

Ejemplo de updateUserNotificationStatus

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t notificationId = U("notification-789");
utility::string_t newStatus = U("read");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-token-abc123"));
api->updateUserNotificationStatus(tenantId, notificationId, newStatus, sso)
.then([](pplx::task<std::shared_ptr<UpdateUserNotificationStatus_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto result = std::make_shared<UpdateUserNotificationStatus_200_response>(*resp);
        }
    } catch (...) {
    }
});

Obtener estados de presencia de usuario

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
urlIdWS	string	Sí
userIds	string	Sí

Respuesta

Devuelve: GetUserPresenceStatuses_200_response

Ejemplo

Ejemplo de getUserPresenceStatuses

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlIdWS = U("wss://realtime.fastcomments.com/socket/tenant-abc");
boost::optional<utility::string_t> optUserIds = U("alice@example.com,bob@example.com");
utility::string_t userIds = optUserIds.value_or(U("alice@example.com"));
auto task = api->getUserPresenceStatuses(tenantId, urlIdWS, userIds)
    .then([](std::shared_ptr<GetUserPresenceStatuses_200_response> resp) {
        if (!resp) return;
        auto copy = std::make_shared<GetUserPresenceStatuses_200_response>(*resp);
    });
task.wait();

Buscar usuarios

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
urlId	string	Sí
usernameStartsWith	string	No
mentionGroupIds	vector<string	No
sso	string	No
searchSection	string	No

Respuesta

Devuelve: SearchUsers_200_response

Ejemplo

Ejemplo de searchUsers

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("/articles/2026/fast-comments-integration");
boost::optional<utility::string_t> usernameStartsWith = boost::optional<utility::string_t>(U("alex"));
std::vector<utility::string_t> groupsVec = { U("editors"), U("contributors") };
boost::optional<std::vector<utility::string_t>> mentionGroupIds = boost::optional<std::vector<utility::string_t>>(groupsVec);
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-user-456"));
boost::optional<utility::string_t> searchSection = boost::optional<utility::string_t>(U("discussion"));
api->searchUsers(tenantId, urlId, usernameStartsWith, mentionGroupIds, sso, searchSection)
    .then([](pplx::task<std::shared_ptr<SearchUsers_200_response>> task) {
        try {
            auto resp = task.get();
            auto respCopy = std::make_shared<SearchUsers_200_response>(*resp);
            (void)respCopy;
        } catch (const std::exception&) {
        }
    });

Obtener usuario

Parámetros

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

Respuesta

Devuelve: GetUser_200_response

Ejemplo

Ejemplo de getUser

Copy

boost::optional<utility::string_t> tenant(U("my-tenant-123"));
boost::optional<utility::string_t> userId(U("user@example.com"));
api->getUser(tenant.value(), userId.value())
    .then([](pplx::task<std::shared_ptr<GetUser_200_response>> task) {
        try {
            auto resp = task.get();
            if (resp) {
                auto result_copy = std::make_shared<GetUser_200_response>(*resp);
            } else {
                auto fallback = std::make_shared<GetUser_200_response>();
            }
        } catch (const std::exception &e) {
        }
    });

Crear voto

Parámetros

Nombre	Tipo	Obligatorio
tenantId	string	Sí
commentId	string	Sí
direction	string	Sí
userId	string	No
anonUserId	string	No

Respuesta

Devuelve: VoteComment_200_response

Ejemplo

Ejemplo de createVote

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
utility::string_t direction = U("up");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
api->createVote(tenantId, commentId, direction, userId, boost::none)
.then([](pplx::task<std::shared_ptr<VoteComment_200_response>> task) {
    try {
        auto resp = task.get();
        if (!resp) resp = std::make_shared<VoteComment_200_response>();
    } catch (...) {}
});

Eliminar voto

Parámetros

Name	Type	Requerido
tenantId	string	Sí
id	string	Sí
editKey	string	No

Respuesta

Devuelve: DeleteCommentVote_200_response

Ejemplo

Ejemplo de deleteVote

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
utility::string_t voteId = utility::conversions::to_string_t("vote-98765");
boost::optional<utility::string_t> editKey = boost::optional<utility::string_t>(utility::conversions::to_string_t("user-edit-key-abc123"));
api->deleteVote(tenantId, voteId, editKey)
.then([](pplx::task<std::shared_ptr<DeleteCommentVote_200_response>> t){
    try {
        auto resp = t.get();
        auto result = resp ? std::make_shared<DeleteCommentVote_200_response>(*resp)
                           : std::make_shared<DeleteCommentVote_200_response>();
        (void)result;
    } catch (const std::exception& e) {
        (void)e;
    }
});

Obtener votos

Parámetros

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

Respuesta

Devuelve: GetVotes_200_response

Ejemplo

Ejemplo de getVotes

Copy

boost::optional<utility::string_t> tenantId = utility::string_t(U("my-tenant-123"));
boost::optional<utility::string_t> urlId = utility::string_t(U("/posts/2025/new-features"));
auto task = api->getVotes(tenantId.value(), urlId.value()).then([](std::shared_ptr<GetVotes_200_response> resp){
    if (resp) {
        auto copy = std::make_shared<GetVotes_200_response>(*resp);
        std::cout << "Fetched votes successfully\n";
    } else {
        std::cout << "No votes response\n";
    }
});
task.wait();

Obtener votos para usuario

Parámetros

Nombre	Tipo	Requerido
tenantId	string	Sí
urlId	string	Sí
userId	string	No
anonUserId	string	No

Respuesta

Devuelve: GetVotesForUser_200_response

Ejemplo

Ejemplo de getVotesForUser

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("article-987");
boost::optional<utility::string_t> userId = utility::string_t(U("user@example.com"));
boost::optional<utility::string_t> anonUserId;
api->getVotesForUser(tenantId, urlId, userId, anonUserId)
.then([](pplx::task<std::shared_ptr<GetVotesForUser_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto copy = std::make_shared<GetVotesForUser_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

¿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

Bloquear desde comentario

Comprobar comentarios bloqueados

Comentarios

Configuraciones de dominio

Plantillas de correo

Registro de eventos

Publicaciones del feed

Marcar comentario

Hashtags

Moderadores

Conteo de notificaciones

Notificaciones

Páginas

Eventos de webhook pendientes

Configuraciones de preguntas

Resultados de preguntas

Agregación de resultados de preguntas

Usuarios SSO

Suscripciones

Uso diario del inquilino

Paquetes del inquilino

Usuarios del inquilino

Inquilinos

Tickets

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 para C++

Repositorio

Requisitos

Instalación

Instalar dependencias

Compilar desde el código fuente

Instalación

Contenido de la biblioteca

APIs públicas frente a protegidas

Inicio rápido

Uso de APIs autenticadas (DefaultAPI)

Uso de APIs públicas (PublicAPI)

Problemas comunes

Realizar llamadas a la API: Sincrónicas vs Asíncronas

Synchronous Calls with .get()

Asynchronous Calls with .then()

Choosing Between Synchronous and Asynchronous

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 la API

Documentación de los Modelos

Agregación

Parámetros

Respuesta

Ejemplo

Obtener registros de auditoría

Parámetros

Respuesta

Ejemplo

Bloquear desde comentario público

Parámetros

Respuesta

Ejemplo

Desbloquear comentario público

Parámetros

Respuesta

Synchronous Calls with `.get()`

Asynchronous Calls with `.then()`