FastComments SDK C++

Questo è l'SDK ufficiale in C++ per FastComments.

SDK ufficiale in C++ per l'API di FastComments

Repository

Requisiti

C++17 o successivo
CMake 3.14 o successivo
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (scaricato automaticamente per i test)

Installazione

Installa dipendenze

sudo apt install libcpprest-dev libboost-all-dev

Compilare dal sorgente

mkdir build
cd build
cmake ..
make

Installazione

sudo make install

Contenuto della libreria

Questa libreria contiene il client API generato e le utility SSO per semplificare l'utilizzo dell'API.

Documentazione della libreria client API

API pubbliche vs sicure

Per il client API, esistono tre classi, DefaultApi, PublicApi e ModerationApi. La DefaultApi contiene metodi che richiedono la tua chiave API, mentre la PublicApi contiene metodi che possono essere chiamati direttamente da un browser/dispositivo mobile/etc senza autenticazione. La ModerationApi offre una vasta suite di API di moderazione in tempo reale e veloce. Ogni metodo della ModerationApi accetta un parametro sso e può autenticarsi tramite SSO o tramite un cookie di sessione di FastComments.com.

Avvio rapido

Utilizzo delle API Autenticate (DefaultAPI)

Importante:

Devi impostare l'URL di base (il generatore cpp-restsdk non lo legge dallo spec OpenAPI)
Devi impostare la tua chiave API sul ApiClient prima di effettuare richieste autenticate. Se non lo fai, le richieste falliranno con un errore 401.

#include <iostream>
#include "FastCommentsClient/api/DefaultApi.h"
#include "FastCommentsClient/ApiClient.h"
#include "FastCommentsClient/ApiConfiguration.h"

int main() {
    auto config = std::make_shared<org::openapitools::client::api::ApiConfiguration>();

    // REQUIRED: Set the base URL (choose your region)
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));  // US
    // OR: config->setBaseUrl(utility::conversions::to_string_t("https://eu.fastcomments.com"));  // EU

    // REQUIRED: Set your API key
    config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_API_KEY_HERE"));

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

    // Now make authenticated API calls
    return 0;
}

Utilizzo delle API Pubbliche (PublicAPI)

Gli endpoint pubblici non richiedono autenticazione:

#include <iostream>
#include "FastCommentsClient/api/PublicApi.h"
#include "FastCommentsClient/ApiClient.h"
#include "FastCommentsClient/ApiConfiguration.h"

int main() {
    auto config = std::make_shared<org::openapitools::client::api::ApiConfiguration>();

    // REQUIRED: Set the base URL
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

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

    // Make public API calls
    return 0;
}

Utilizzo delle API di Moderazione (ModerationApi)

La ModerationApi alimenta la dashboard del moderatore. Ogni metodo accetta un parametro sso così la chiamata viene eseguita per conto di un moderatore autenticato via SSO (vedi la sezione SSO più sotto per sapere come creare un token):

#include <iostream>
#include "FastCommentsClient/api/ModerationApi.h"
#include "FastCommentsClient/ApiClient.h"
#include "FastCommentsClient/ApiConfiguration.h"

int main() {
    auto config = std::make_shared<org::openapitools::client::api::ApiConfiguration>();

    // REQUIRED: Set the base URL
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

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

    // Pass the moderator's SSO token to authenticate the call
    auto ssoToken = utility::conversions::to_string_t("YOUR_MODERATOR_SSO_TOKEN");

    org::openapitools::client::api::GetCountOptions options;
    options.sso = ssoToken;

    auto response = moderationApi.getCount(options).get();

    return 0;
}

Problemi comuni

"URI must contain a hostname" error: Assicurati di chiamare config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) prima di creare l'ApiClient. Il generatore cpp-restsdk non legge automaticamente l'URL del server dallo spec OpenAPI.
401 "missing-api-key" error: Assicurati di chiamare config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) prima di creare l'istanza DefaultAPI.
Wrong API class: Usa DefaultApi per richieste autenticate lato server, PublicApi per richieste lato client/pubbliche, e ModerationApi per richieste della dashboard del moderatore (autenticate con un token SSO del moderatore).

Eseguire chiamate API: sincrone vs asincrone

Tutti i metodi API in questo SDK restituiscono pplx::task<std::shared_ptr<ResponseType>> dal C++ REST SDK. Questo ti dà flessibilità nel modo in cui gestisci le risposte API.

Chiamate sincrone con `.get()`

Usa .get() per bloccare il thread chiamante finché la richiesta non è completata e recuperare il risultato in modo sincrono:

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

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

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

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

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

Chiamate asincrone con `.then()`

Usa .then() per esecuzione asincrona non bloccante con callback:

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

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

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

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

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

Scegliere tra sincrono e asincrono

La scelta dipende dal tuo ambiente di runtime e dall'architettura dell'applicazione:

.get() (Blocco sincrono)

Blocca il thread chiamante finché la richiesta HTTP non è completata
Flusso di codice più semplice, più facile da comprendere
Adatto a thread di lavoro dedicati, elaborazione batch o strumenti da riga di comando
Non adatto a loop di eventi, thread GUI o server monothread

.then() (Asincrono non bloccante)

Ritorna immediatamente, il callback viene eseguito quando la richiesta è completata
Non blocca il thread chiamante
Necessario per architetture guidate dagli eventi, applicazioni GUI o loop di eventi monothread
Consente il concatenamento di più operazioni
Flusso di controllo più complesso

La suite di test dell'SDK utilizza .get() esclusivamente, ma ciò è appropriato per l'ambiente di test dove il blocco è accettabile.

Note

ID di broadcast

Vedrai che dovrai passare un broadcastId in alcune chiamate API. Quando ricevi eventi, riceverai indietro questo ID, così saprai di ignorare l'evento se prevedi di applicare ottimisticamente le modifiche sul client (il che probabilmente vorrai fare, poiché offre la migliore esperienza). Passa qui un UUID. L'ID dovrebbe essere sufficientemente unico da non comparire due volte in una sessione del browser.

SSO (Accesso unico)

Per esempi di SSO, vedi sotto.

Utilizzo SSO

SSO semplice

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

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

Documentazione per fastcomments

Documentazione per gli endpoint API

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

Classe	Metodo	Richiesta HTTP	Descrizione
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	Aggrega i documenti raggruppandoli (se groupBy è fornito) e applicando più operazioni. Diverse operazioni (ad es. sum, countDistinct, avg, ecc.) sono supportate.
DefaultApi	aggregateQuestionResults	GET /api/v1/question-results-aggregation
DefaultApi	blockUserFromComment	POST /api/v1/comments/{id}/block
DefaultApi	bulkAggregateQuestionResults	POST /api/v1/question-results-aggregation/bulk
DefaultApi	changeTicketState	PATCH /api/v1/tickets/{id}/state
DefaultApi	combineCommentsWithQuestionResults	GET /api/v1/question-results-aggregation/combine/comments
DefaultApi	createEmailTemplate	POST /api/v1/email-templates
DefaultApi	createFeedPost	POST /api/v1/feed-posts
DefaultApi	createModerator	POST /api/v1/moderators
DefaultApi	createQuestionConfig	POST /api/v1/question-configs
DefaultApi	createQuestionResult	POST /api/v1/question-results
DefaultApi	createSubscription	POST /api/v1/subscriptions
DefaultApi	createTenant	POST /api/v1/tenants
DefaultApi	createTenantPackage	POST /api/v1/tenant-packages
DefaultApi	createTenantUser	POST /api/v1/tenant-users
DefaultApi	createTicket	POST /api/v1/tickets
DefaultApi	createUserBadge	POST /api/v1/user-badges
DefaultApi	createVote	POST /api/v1/votes
DefaultApi	deleteComment	DELETE /api/v1/comments/{id}
DefaultApi	deleteDomainConfig	DELETE /api/v1/domain-configs/{domain}
DefaultApi	deleteEmailTemplate	DELETE /api/v1/email-templates/{id}
DefaultApi	deleteEmailTemplateRenderError	DELETE /api/v1/email-templates/{id}/render-errors/{errorId}
DefaultApi	deleteHashTag	DELETE /api/v1/hash-tags/{tag}
DefaultApi	deleteModerator	DELETE /api/v1/moderators/{id}
DefaultApi	deleteNotificationCount	DELETE /api/v1/notification-count/{id}
DefaultApi	deletePage	DELETE /api/v1/pages/{id}
DefaultApi	deletePendingWebhookEvent	DELETE /api/v1/pending-webhook-events/{id}
DefaultApi	deleteQuestionConfig	DELETE /api/v1/question-configs/{id}
DefaultApi	deleteQuestionResult	DELETE /api/v1/question-results/{id}
DefaultApi	deleteSSOUser	DELETE /api/v1/sso-users/{id}
DefaultApi	deleteSubscription	DELETE /api/v1/subscriptions/{id}
DefaultApi	deleteTenant	DELETE /api/v1/tenants/{id}
DefaultApi	deleteTenantPackage	DELETE /api/v1/tenant-packages/{id}
DefaultApi	deleteTenantUser	DELETE /api/v1/tenant-users/{id}
DefaultApi	deleteUserBadge	DELETE /api/v1/user-badges/{id}
DefaultApi	deleteVote	DELETE /api/v1/votes/{id}
DefaultApi	flagComment	POST /api/v1/comments/{id}/flag
DefaultApi	getAuditLogs	GET /api/v1/audit-logs
DefaultApi	getCachedNotificationCount	GET /api/v1/notification-count/{id}
DefaultApi	getComment	GET /api/v1/comments/{id}
DefaultApi	getComments	GET /api/v1/comments
DefaultApi	getDomainConfig	GET /api/v1/domain-configs/{domain}
DefaultApi	getDomainConfigs	GET /api/v1/domain-configs
DefaultApi	getEmailTemplate	GET /api/v1/email-templates/{id}
DefaultApi	getEmailTemplateDefinitions	GET /api/v1/email-templates/definitions
DefaultApi	getEmailTemplateRenderErrors	GET /api/v1/email-templates/{id}/render-errors
DefaultApi	getEmailTemplates	GET /api/v1/email-templates
DefaultApi	getFeedPosts	GET /api/v1/feed-posts	req tenantId afterId
DefaultApi	getHashTags	GET /api/v1/hash-tags
DefaultApi	getModerator	GET /api/v1/moderators/{id}
DefaultApi	getModerators	GET /api/v1/moderators
DefaultApi	getNotificationCount	GET /api/v1/notifications/count
DefaultApi	getNotifications	GET /api/v1/notifications
DefaultApi	getPageByURLId	GET /api/v1/pages/by-url-id
DefaultApi	getPages	GET /api/v1/pages
DefaultApi	getPendingWebhookEventCount	GET /api/v1/pending-webhook-events/count
DefaultApi	getPendingWebhookEvents	GET /api/v1/pending-webhook-events
DefaultApi	getQuestionConfig	GET /api/v1/question-configs/{id}
DefaultApi	getQuestionConfigs	GET /api/v1/question-configs
DefaultApi	getQuestionResult	GET /api/v1/question-results/{id}
DefaultApi	getQuestionResults	GET /api/v1/question-results
DefaultApi	getSSOUserByEmail	GET /api/v1/sso-users/by-email/{email}
DefaultApi	getSSOUserById	GET /api/v1/sso-users/by-id/{id}
DefaultApi	getSSOUsers	GET /api/v1/sso-users
DefaultApi	getSubscriptions	GET /api/v1/subscriptions
DefaultApi	getTenant	GET /api/v1/tenants/{id}
DefaultApi	getTenantDailyUsages	GET /api/v1/tenant-daily-usage
DefaultApi	getTenantPackage	GET /api/v1/tenant-packages/{id}
DefaultApi	getTenantPackages	GET /api/v1/tenant-packages
DefaultApi	getTenantUser	GET /api/v1/tenant-users/{id}
DefaultApi	getTenantUsers	GET /api/v1/tenant-users
DefaultApi	getTenants	GET /api/v1/tenants
DefaultApi	getTicket	GET /api/v1/tickets/{id}
DefaultApi	getTickets	GET /api/v1/tickets
DefaultApi	getUser	GET /api/v1/users/{id}
DefaultApi	getUserBadge	GET /api/v1/user-badges/{id}
DefaultApi	getUserBadgeProgressById	GET /api/v1/user-badge-progress/{id}
DefaultApi	getUserBadgeProgressByUserId	GET /api/v1/user-badge-progress/user/{userId}
DefaultApi	getUserBadgeProgressList	GET /api/v1/user-badge-progress
DefaultApi	getUserBadges	GET /api/v1/user-badges
DefaultApi	getVotes	GET /api/v1/votes
DefaultApi	getVotesForUser	GET /api/v1/votes/for-user
DefaultApi	patchDomainConfig	PATCH /api/v1/domain-configs/{domainToUpdate}
DefaultApi	patchHashTag	PATCH /api/v1/hash-tags/{tag}
DefaultApi	patchPage	PATCH /api/v1/pages/{id}
DefaultApi	patchSSOUser	PATCH /api/v1/sso-users/{id}
DefaultApi	putDomainConfig	PUT /api/v1/domain-configs/{domainToUpdate}
DefaultApi	putSSOUser	PUT /api/v1/sso-users/{id}
DefaultApi	renderEmailTemplate	POST /api/v1/email-templates/render
DefaultApi	replaceTenantPackage	PUT /api/v1/tenant-packages/{id}
DefaultApi	replaceTenantUser	PUT /api/v1/tenant-users/{id}
DefaultApi	saveComment	POST /api/v1/comments
DefaultApi	saveCommentsBulk	POST /api/v1/comments/bulk
DefaultApi	sendInvite	POST /api/v1/moderators/{id}/send-invite
DefaultApi	sendLoginLink	POST /api/v1/tenant-users/{id}/send-login-link
DefaultApi	unBlockUserFromComment	POST /api/v1/comments/{id}/un-block
DefaultApi	unFlagComment	POST /api/v1/comments/{id}/un-flag
DefaultApi	updateComment	PATCH /api/v1/comments/{id}
DefaultApi	updateEmailTemplate	PATCH /api/v1/email-templates/{id}
DefaultApi	updateFeedPost	PATCH /api/v1/feed-posts/{id}
DefaultApi	updateModerator	PATCH /api/v1/moderators/{id}
DefaultApi	updateNotification	PATCH /api/v1/notifications/{id}
DefaultApi	updateQuestionConfig	PATCH /api/v1/question-configs/{id}
DefaultApi	updateQuestionResult	PATCH /api/v1/question-results/{id}
DefaultApi	updateSubscription	PATCH /api/v1/subscriptions/{id}
DefaultApi	updateTenant	PATCH /api/v1/tenants/{id}
DefaultApi	updateTenantPackage	PATCH /api/v1/tenant-packages/{id}
DefaultApi	updateTenantUser	PATCH /api/v1/tenant-users/{id}
DefaultApi	updateUserBadge	PUT /api/v1/user-badges/{id}
ModerationApi	deleteModerationVote	DELETE /auth/my-account/moderate-comments/mod_api/vote/{commentId}/{voteId}
ModerationApi	getApiComments	GET /auth/my-account/moderate-comments/mod_api/api/comments
ModerationApi	getApiExportStatus	GET /auth/my-account/moderate-comments/mod_api/api/export/status
ModerationApi	getApiIds	GET /auth/my-account/moderate-comments/mod_api/api/ids
ModerationApi	getBanUsersFromComment	GET /auth/my-account/moderate-comments/mod_api/ban-users/from-comment/{commentId}
ModerationApi	getCommentBanStatus	GET /auth/my-account/moderate-comments/mod_api/get-comment-ban-status/{commentId}
ModerationApi	getCommentChildren	GET /auth/my-account/moderate-comments/mod_api/comment-children/{commentId}
ModerationApi	getCount	GET /auth/my-account/moderate-comments/mod_api/count
ModerationApi	getCounts	GET /auth/my-account/moderate-comments/banned-users/mod_api/counts
ModerationApi	getLogs	GET /auth/my-account/moderate-comments/mod_api/logs/{commentId}
ModerationApi	getManualBadges	GET /auth/my-account/moderate-comments/mod_api/get-manual-badges
ModerationApi	getManualBadgesForUser	GET /auth/my-account/moderate-comments/mod_api/get-manual-badges-for-user
ModerationApi	getModerationComment	GET /auth/my-account/moderate-comments/mod_api/comment/{commentId}
ModerationApi	getModerationCommentText	GET /auth/my-account/moderate-comments/mod_api/get-comment-text/{commentId}
ModerationApi	getPreBanSummary	GET /auth/my-account/moderate-comments/mod_api/pre-ban-summary/{commentId}
ModerationApi	getSearchCommentsSummary	GET /auth/my-account/moderate-comments/mod_api/search/comments/summary
ModerationApi	getSearchPages	GET /auth/my-account/moderate-comments/mod_api/search/pages
ModerationApi	getSearchSites	GET /auth/my-account/moderate-comments/mod_api/search/sites
ModerationApi	getSearchSuggest	GET /auth/my-account/moderate-comments/mod_api/search/suggest
ModerationApi	getSearchUsers	GET /auth/my-account/moderate-comments/mod_api/search/users
ModerationApi	getTrustFactor	GET /auth/my-account/moderate-comments/mod_api/get-trust-factor
ModerationApi	getUserBanPreference	GET /auth/my-account/moderate-comments/mod_api/user-ban-preference
ModerationApi	getUserInternalProfile	GET /auth/my-account/moderate-comments/mod_api/get-user-internal-profile
ModerationApi	postAdjustCommentVotes	POST /auth/my-account/moderate-comments/mod_api/adjust-comment-votes/{commentId}
ModerationApi	postApiExport	POST /auth/my-account/moderate-comments/mod_api/api/export
ModerationApi	postBanUserFromComment	POST /auth/my-account/moderate-comments/mod_api/ban-user/from-comment/{commentId}
ModerationApi	postBanUserUndo	POST /auth/my-account/moderate-comments/mod_api/ban-user/undo
ModerationApi	postBulkPreBanSummary	POST /auth/my-account/moderate-comments/mod_api/bulk-pre-ban-summary
ModerationApi	postCommentsByIds	POST /auth/my-account/moderate-comments/mod_api/comments-by-ids
ModerationApi	postFlagComment	POST /auth/my-account/moderate-comments/mod_api/flag-comment/{commentId}
ModerationApi	postRemoveComment	POST /auth/my-account/moderate-comments/mod_api/remove-comment/{commentId}
ModerationApi	postRestoreDeletedComment	POST /auth/my-account/moderate-comments/mod_api/restore-deleted-comment/{commentId}
ModerationApi	postSetCommentApprovalStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-approval-status/{commentId}
ModerationApi	postSetCommentReviewStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-review-status/{commentId}
ModerationApi	postSetCommentSpamStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-spam-status/{commentId}
ModerationApi	postSetCommentText	POST /auth/my-account/moderate-comments/mod_api/set-comment-text/{commentId}
ModerationApi	postUnFlagComment	POST /auth/my-account/moderate-comments/mod_api/un-flag-comment/{commentId}
ModerationApi	postVote	POST /auth/my-account/moderate-comments/mod_api/vote/{commentId}
ModerationApi	putAwardBadge	PUT /auth/my-account/moderate-comments/mod_api/award-badge
ModerationApi	putCloseThread	PUT /auth/my-account/moderate-comments/mod_api/close-thread
ModerationApi	putRemoveBadge	PUT /auth/my-account/moderate-comments/mod_api/remove-badge
ModerationApi	putReopenThread	PUT /auth/my-account/moderate-comments/mod_api/reopen-thread
ModerationApi	setTrustFactor	PUT /auth/my-account/moderate-comments/mod_api/set-trust-factor
PublicApi	blockFromCommentPublic	POST /block-from-comment/{commentId}
PublicApi	checkedCommentsForBlocked	GET /check-blocked-comments
PublicApi	createCommentPublic	POST /comments/{tenantId}
PublicApi	createFeedPostPublic	POST /feed-posts/{tenantId}
PublicApi	createV1PageReact	POST /page-reacts/v1/likes/{tenantId}
PublicApi	createV2PageReact	POST /page-reacts/v2/{tenantId}
PublicApi	deleteCommentPublic	DELETE /comments/{tenantId}/{commentId}
PublicApi	deleteCommentVote	DELETE /comments/{tenantId}/{commentId}/vote/{voteId}
PublicApi	deleteFeedPostPublic	DELETE /feed-posts/{tenantId}/{postId}
PublicApi	deleteV1PageReact	DELETE /page-reacts/v1/likes/{tenantId}
PublicApi	deleteV2PageReact	DELETE /page-reacts/v2/{tenantId}
PublicApi	flagCommentPublic	POST /flag-comment/{commentId}
PublicApi	getCommentText	GET /comments/{tenantId}/{commentId}/text
PublicApi	getCommentVoteUserNames	GET /comments/{tenantId}/{commentId}/votes
PublicApi	getCommentsForUser	GET /comments-for-user
PublicApi	getCommentsPublic	GET /comments/{tenantId}	richiede tenantId urlId
PublicApi	getEventLog	GET /event-log/{tenantId}	richiede tenantId urlId userIdWS
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	richiede tenantId afterId
PublicApi	getFeedPostsStats	GET /feed-posts/{tenantId}/stats
PublicApi	getGifLarge	GET /gifs/get-large/{tenantId}
PublicApi	getGifsSearch	GET /gifs/search/{tenantId}
PublicApi	getGifsTrending	GET /gifs/trending/{tenantId}
PublicApi	getGlobalEventLog	GET /event-log/global/{tenantId}	richiede tenantId urlId userIdWS
PublicApi	getOfflineUsers	GET /pages/{tenantId}/users/offline	Commentatori precedenti sulla pagina che NON sono attualmente online. Ordinati per displayName. Utilizzare questo dopo aver esaurito /users/online per rendere una sezione "Members". Paginazione cursore su commenterName: il server percorre l'indice parziale {tenantId, urlId, commenterName} da afterName in avanti tramite $gt, senza costo $skip.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	Visualizzatori attualmente online di una pagina: persone la cui sessione websocket è attualmente iscritta alla pagina. Restituisce anonCount + totalCount (abbonati a tutta la stanza, inclusi gli spettatori anonimi non elencati).
PublicApi	getPagesPublic	GET /pages/{tenantId}	Elenca le pagine per un tenant. Utilizzato dal client desktop FChat per popolare la sua lista di stanze. Richiede che `enableFChat` sia true nella configurazione personalizzata risolta per ogni pagina. Le pagine che richiedono SSO sono filtrate in base all'accesso di gruppo dell'utente richiedente.
PublicApi	getTranslations	GET /translations/{namespace}/{component}
PublicApi	getUserNotificationCount	GET /user-notifications/get-count
PublicApi	getUserNotifications	GET /user-notifications
PublicApi	getUserPresenceStatuses	GET /user-presence-status
PublicApi	getUserReactsPublic	GET /feed-posts/{tenantId}/user-reacts
PublicApi	getUsersInfo	GET /pages/{tenantId}/users/info	Informazioni utente in blocco per un tenant. Dati gli userIds, restituisce le informazioni visualizzabili da User / SSOUser. Utilizzato dal widget dei commenti per arricchire gli utenti appena apparsi tramite un evento di presenza. Nessun contesto di pagina: la privacy è applicata uniformemente (i profili privati sono mascherati).
PublicApi	getV1PageLikes	GET /page-reacts/v1/likes/{tenantId}
PublicApi	getV2PageReactUsers	GET /page-reacts/v2/{tenantId}/list
PublicApi	getV2PageReacts	GET /page-reacts/v2/{tenantId}
PublicApi	lockComment	POST /comments/{tenantId}/{commentId}/lock
PublicApi	logoutPublic	PUT /auth/logout
PublicApi	pinComment	POST /comments/{tenantId}/{commentId}/pin
PublicApi	reactFeedPostPublic	POST /feed-posts/{tenantId}/react/{postId}
PublicApi	resetUserNotificationCount	POST /user-notifications/reset-count
PublicApi	resetUserNotifications	POST /user-notifications/reset
PublicApi	searchUsers	GET /user-search/{tenantId}
PublicApi	setCommentText	POST /comments/{tenantId}/{commentId}/update-text
PublicApi	unBlockCommentPublic	DELETE /block-from-comment/{commentId}
PublicApi	unLockComment	POST /comments/{tenantId}/{commentId}/unlock
PublicApi	unPinComment	POST /comments/{tenantId}/{commentId}/unpin
PublicApi	updateFeedPostPublic	PUT /feed-posts/{tenantId}/{postId}
PublicApi	updateUserNotificationCommentSubscriptionStatus	POST /user-notifications/{notificationId}/mark-opted/{optedInOrOut}	Abilita o disabilita le notifiche per un commento specifico.
PublicApi	[updateUserNotificationPageSubscriptionStatus

aggregate

Aggrega i documenti raggruppandoli (se groupBy è fornito) e applicando più operazioni.
Sono supportate diverse operazioni (ad es. sum, countDistinct, avg, ecc.).

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
aggregationRequest	AggregationRequest	Yes
options	const AggregateOptions&	Yes

Risposta

Restituisce: AggregateResponse

Esempio

Esempio di aggregazione

Copy

utility::string_t tenantId = U("my-tenant-123");
AggregationRequest aggregationRequest;
aggregationRequest.setMetric(U("commentCount"));
aggregationRequest.setStartDate(U("2023-01-01T00:00:00Z"));
aggregationRequest.setEndDate(U("2023-12-31T23:59:59Z"));
aggregationRequest.setFilters({ U("status:approved") });
AggregateOptions options;
options.limit = boost::optional<int>(100);
options.includeMetadata = boost::optional<bool>(true);
api->aggregate(tenantId, aggregationRequest, options)
    .then([](pplx::task<std::shared_ptr<AggregateResponse>> task) {
        try {
            auto response = task.get();
            // process response
        } catch (const std::exception& e) {
            // handle error
        }
    });

getAuditLogs

Parametri

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

Risposta

Restituisce: GetAuditLogsResponse

Esempio

Esempio getAuditLogs

Copy

utility::string_t tenantId = U("my-tenant-123");
GetAuditLogsOptions options;
options.startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-01T00:00:00Z"), utility::datetime::RFC_1123));
options.endDate   = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-31T23:59:59Z"), utility::datetime::RFC_1123));
options.limit     = boost::optional<int>(100);
api->getAuditLogs(tenantId, options).then([](pplx::task<std::shared_ptr<GetAuditLogsResponse>> t) {
    try {
        auto response = t.get();
        // usa la risposta
    } catch (const std::exception& e) {
        // gestisci l'errore
    }
});

logoutPublic

Risposta

Restituisce: APIEmptyResponse

Esempio

logoutPublic Esempio

Copy

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

blockFromCommentPublic

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
commentId	string	Yes
publicBlockFromCommentParams	PublicBlockFromCommentParams	Yes
sso	string	No

Risposta

Restituisce: BlockSuccess

Esempio

Esempio blockFromCommentPublic

Copy

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

unBlockCommentPublic

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
commentId	string	Yes
publicBlockFromCommentParams	PublicBlockFromCommentParams	Yes
sso	string	No

Risposta

Restituisce: UnblockSuccess

Esempio

Esempio unBlockCommentPublic

Copy

auto blockParams = PublicBlockFromCommentParams();  
blockParams.reason = U("spam");  
api->unBlockCommentPublic(  
    U("my-tenant-123"),  
    U("comment-789"),  
    blockParams,  
    boost::optional<utility::string_t>(U("sso-token-abc"))  
).then([](std::shared_ptr<UnblockSuccess> result){ });

checkedCommentsForBlocked

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
commentIds	string	Yes
sso	string	No

Risposta

Restituisce: CheckBlockedCommentsResponse

Esempio

checkedCommentsForBlocked Esempio

Copy

auto tenantId = U("my-tenant-123");
auto commentIds = U("cmt-001,cmt-002");
boost::optional<utility::string_t> sso = U("user@example.com");
api->checkedCommentsForBlocked(tenantId, commentIds, sso).then([](std::shared_ptr<CheckBlockedCommentsResponse> resp){
    (void)resp;
});

blockUserFromComment

Parameters

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
blockFromCommentParams	BlockFromCommentParams	Sì
options	const BlockUserFromCommentOptions&	Sì

Response

Restituisce: BlockSuccess

Example

Esempio blockUserFromComment

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-789");
BlockFromCommentParams params;
params.reason = utility::conversions::to_string_t("Inappropriate content");
params.durationDays = boost::optional<int>(30);
BlockUserFromCommentOptions options;
options.notifyUser = boost::optional<bool>(true);
api->blockUserFromComment(tenantId, commentId, params, options)
    .then([](std::shared_ptr<BlockSuccess> result){ })
    .then([](pplx::task<void> t){ try { t.get(); } catch (const std::exception&) { } });

createCommentPublic

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
urlId	string	Sì
broadcastId	string	Sì
commentData	CommentData	Sì
options	const CreateCommentPublicOptions&	Sì

Risposta

Restituisce: SaveCommentsResponseWithPresence

Esempio

Esempio createCommentPublic

Copy

auto comment = CommentData();
comment.body = U("This is a test comment");
comment.authorName = U("John Doe");
comment.authorEmail = U("john.doe@example.com");
CreateCommentPublicOptions opts;
opts.replyToCommentId = boost::optional<utility::string_t>(U("parent-123"));
api->createCommentPublic(
    U("my-tenant-123"),
    U("article-456"),
    U("broadcast-789"),
    comment,
    opts).then([](std::shared_ptr<SaveCommentsResponseWithPresence> res){
        auto commentId = res->commentId;
    });

deleteComment

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
options	const DeleteCommentOptions&	Sì

Risposta

Restituisce: DeleteCommentResult

Esempio

Esempio deleteComment

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-789");
DeleteCommentOptions options;
options.reason = boost::optional<utility::string_t>(utility::conversions::to_string_t("Inappropriate content"));
options.force = boost::optional<bool>(true);
api->deleteComment(tenantId, commentId, options).then([](pplx::task<std::shared_ptr<DeleteCommentResult>> task){
    try{
        auto result = task.get();
    }catch(const std::exception&){
    }
});

deleteCommentPublic

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
options	const DeleteCommentPublicOptions&	Yes

Risposta

Restituisce: PublicAPIDeleteCommentResponse

Esempio

Esempio deleteCommentPublic

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto commentId = utility::string_t(U("comment-456"));
auto broadcastId = utility::string_t(U("broadcast-789"));
DeleteCommentPublicOptions options;
options.force = boost::optional<bool>(true);
options.reason = boost::optional<utility::string_t>(U("Inappropriate content"));
api->deleteCommentPublic(tenantId, commentId, broadcastId, options)
    .then([](pplx::task<std::shared_ptr<PublicAPIDeleteCommentResponse>> t){
        try{
            auto resp = t.get();
        }catch(const std::exception& e){
        }
    });

deleteCommentVote

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
voteId	string	Sì
urlId	string	Sì
broadcastId	string	Sì
options	const DeleteCommentVoteOptions&	Sì

Risposta

Restituisce: VoteDeleteResponse

Esempio

Esempio deleteCommentVote

Copy

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

flagComment

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
options	const FlagCommentOptions&	Sì

Risposta

Restituisce: FlagCommentResponse

Esempio

Esempio di flagComment

Copy

auto opts = std::make_shared<FlagCommentOptions>();
opts->reason = utility::conversions::to_string_t("spam");
opts->note = boost::optional<utility::string_t>(utility::conversions::to_string_t("User posted duplicate links"));
api->flagComment(utility::conversions::to_string_t("my-tenant-123"),
                 utility::conversions::to_string_t("comment-456"),
                 *opts)
    .then([](pplx::task<std::shared_ptr<FlagCommentResponse>> t) {
        auto resp = t.get();
    });

getComment

Parametri

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

Risposta

Restituisce: APIGetCommentResponse

Esempio

Esempio getComment

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-456");
boost::optional<int> maxDepth = boost::none;
api->getComment(tenantId, commentId).then([](pplx::task<std::shared_ptr<APIGetCommentResponse>> t){
    try{
        auto resp = t.get();
    }catch(const std::exception&){
    }
});

getComments

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetCommentsOptions&	Sì

Risposta

Restituisce: APIGetCommentsResponse

Esempio

Esempio getComments

Copy

utility::string_t tenantId = U("my-tenant-123");
GetCommentsOptions options;
options.page = 1;
options.limit = 50;
options.sort = U("newest");
options.authorEmail = boost::optional<utility::string_t>(U("user@example.com"));
api->getComments(tenantId, options).then([](pplx::task<std::shared_ptr<APIGetCommentsResponse>> task) {
    try {
        auto response = task.get();
        // utilizzare la risposta secondo necessità
    } catch (const std::exception& e) {
        // gestire l'errore
    }
});

getCommentsPublic

richiesta tenantId urlId

Parameters

Nome	Tipo	Obbligatorio
tenantId	string	Sì
urlId	string	Sì
options	const GetCommentsPublicOptions&	Sì

Response

Restituisce: GetCommentsResponseWithPresence_PublicComment_

Example

Esempio getCommentsPublic

Copy

auto tenantId = U("my-tenant-123");
auto urlId = U("article-456");
GetCommentsPublicOptions opts;
opts.pageSize = 20;
opts.includeDeleted = false;
api->getCommentsPublic(tenantId, urlId, opts).then([](std::shared_ptr<GetCommentsResponseWithPresence_PublicComment_> resp) {
    (void)resp;
});

getCommentText

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
options	const GetCommentTextOptions&	Sì

Risposta

Restituisce: PublicAPIGetCommentTextResponse

Esempio

Esempio getCommentText

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
auto options = std::make_shared<GetCommentTextOptions>();
options->language = boost::optional<utility::string_t>(U("en"));
options->includeDeleted = boost::optional<bool>(false);
api->getCommentText(tenantId, commentId, *options).then([](pplx::task<std::shared_ptr<PublicAPIGetCommentTextResponse>> task){
    try{
        auto response = task.get();
        (void)response;
    }catch(...){}
});

getCommentVoteUserNames

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
dir	int32_t	Sì
sso	string	No

Risposta

Restituisce: GetCommentVoteUserNamesSuccessResponse

Esempio

Esempio getCommentVoteUserNames

Copy

auto task = api->getCommentVoteUserNames(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("comment-456"),
    static_cast<int32_t>(1),
    boost::optional<utility::string_t>(utility::conversions::to_string_t("sso-token"))
).then([](pplx::task<std::shared_ptr<GetCommentVoteUserNamesSuccessResponse>> t){
    try{
        auto response = t.get();
    }catch(const std::exception&){ }
});

lockComment

Parametri

Name	Type	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
broadcastId	string	Sì
sso	string	No

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio lockComment

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-987");
auto broadcastId = utility::conversions::to_string_t("broadcast-654");
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("sso-token-xyz");
api->lockComment(tenantId, commentId, broadcastId, sso).then([](pplx::task<std::shared_ptr<APIEmptyResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){
    }
});

pinComment

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Risposta

Restituisce: ChangeCommentPinStatusResponse

Esempio

Esempio pinComment

Copy

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

saveComment

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
createCommentParams	CreateCommentParams	Sì
options	const SaveCommentOptions&	Sì

Risposta

Restituisce: APISaveCommentResponse

Esempio

Esempio saveComment

Copy

CreateCommentParams commentParams;
commentParams.body = utility::string_t(U("Great article!"));
commentParams.author = utility::string_t(U("jane.doe@example.com"));
commentParams.parentId = boost::optional<utility::string_t>(utility::string_t(U("parent-789")));
SaveCommentOptions options;
options.preview = boost::optional<bool>(false);
api->saveComment(utility::string_t(U("my-tenant-123")), commentParams, options)
    .then([](std::shared_ptr<APISaveCommentResponse> response) {
        auto commentId = response->commentId;
    });

setCommentText

Parametri

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
commentTextUpdateRequest	CommentTextUpdateRequest	Yes
options	const SetCommentTextOptions&	Yes

Risposta

Restituisce: PublicAPISetCommentTextResponse

Esempio

Esempio setCommentText

Copy

auto tenantId = U("my-tenant-123");
auto commentId = U("cmt-456");
auto broadcastId = U("brd-789");
CommentTextUpdateRequest updateReq;
updateReq.text = U("Updated comment content");
updateReq.isEdited = boost::make_optional(true);
SetCommentTextOptions opts;
opts.notifySubscribers = boost::make_optional(true);
api->setCommentText(tenantId, commentId, broadcastId, updateReq, opts)
    .then([](std::shared_ptr<PublicAPISetCommentTextResponse> resp) {
    });

unBlockUserFromComment

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
unBlockFromCommentParams	UnBlockFromCommentParams	Sì
options	const UnBlockUserFromCommentOptions&	Sì

Risposta

Ritorna: UnblockSuccess

Esempio

unBlockUserFromComment Esempio

Copy

auto params = std::make_shared<UnBlockFromCommentParams>();
params->commentId = U("cmt-12345");
params->reason = U("resolved");
UnBlockUserFromCommentOptions opts;
opts.notifyUser = boost::optional<bool>(true);
api->unBlockUserFromComment(U("my-tenant-123"), U("user-456"), *params, opts)
    .then([](pplx::task<std::shared_ptr<UnblockSuccess>> t){
        try{
            auto result = t.get();
        }catch(...){}
    });

unFlagComment

Parameters

Nome	Tipo	Obbligatorio
tenantId	string	Yes
id	string	Yes
options	const UnFlagCommentOptions&	Yes

Response

Restituisce: FlagCommentResponse

Example

Esempio unFlagComment

Copy

auto options = UnFlagCommentOptions{};
options.reason = boost::optional<utility::string_t>(U("Resolved by moderator"));
api->unFlagComment(U("my-tenant-123"), U("comment-456"), options)
    .then([](std::shared_ptr<FlagCommentResponse> response) {
        if (response) {
            auto status = response->status;
            // elaborare lo stato se necessario
        }
    })
    .then([](pplx::task<void> previous) {
        try {
            previous.get();
        } catch (const std::exception& e) {
            // gestire l'errore
        }
    });

unLockComment

Parameters

Name	Type	Required
tenantId	string	Sì
commentId	string	Sì
broadcastId	string	Sì
sso	string	No

Response

Restituisce: APIEmptyResponse

Example

Esempio di unLockComment

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("cmt-456789");
auto broadcastId = utility::conversions::to_string_t("broadcast-001");
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("john.doe@example.com");
api->unLockComment(tenantId, commentId, broadcastId, sso).then([](pplx::task<std::shared_ptr<APIEmptyResponse>> task) {
    try {
        auto response = task.get();
    } catch (const std::exception&) {
    }
});

unPinComment

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Risposta

Restituisce: ChangeCommentPinStatusResponse

Esempio

Esempio unPinComment

Copy

auto task = api->unPinComment(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("cmt-456789"),
    utility::conversions::to_string_t("broadcast-001"),
    boost::optional<utility::string_t>(utility::conversions::to_string_t("user@example.com"))
);
task.then([](std::shared_ptr<ChangeCommentPinStatusResponse> resp){
    auto result = std::make_shared<ChangeCommentPinStatusResponse>(*resp);
});

updateComment

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
updatableCommentParams	UpdatableCommentParams	Sì
options	const UpdateCommentOptions&	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio updateComment

Copy

auto tenantId = utility::string_t("my-tenant-123");
auto commentId = utility::string_t("cmt-789");
UpdatableCommentParams updatable;
updatable.body = utility::string_t("Edited comment content");
updatable.isSpam = boost::optional<bool>(false);
UpdateCommentOptions options;
options.notify = boost::optional<bool>(true);
api->updateComment(tenantId, commentId, updatable, options)
    .then([](std::shared_ptr<APIEmptyResponse>) {})
    .then([](pplx::task<void> t) { try { t.get(); } catch(const std::exception&) {} });

voteComment

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
commentId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
voteBodyParams	VoteBodyParams	Yes
options	const VoteCommentOptions&	Yes

Risposta

Restituisce: VoteResponse

Esempio

Esempio voteComment

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-7890");
auto urlId = utility::conversions::to_string_t("article-456");
auto broadcastId = utility::conversions::to_string_t("broadcast-321");
VoteBodyParams voteParams;
voteParams.upvote = true;
voteParams.note = boost::optional<utility::string_t>(utility::conversions::to_string_t("Great insight"));
VoteCommentOptions options;
options.dryRun = boost::optional<bool>(false);
api->voteComment(tenantId, commentId, urlId, broadcastId, voteParams, options)
   .then([](pplx::task<std::shared_ptr<VoteResponse>> t) {
       try {
           auto response = t.get();
           // gestire la risposta
       } catch (const std::exception&) {
       }
   });

getCommentsForUser

Parameters

Name	Type	Required	Description
options	const GetCommentsForUserOptions&	Yes

Response

Restituisce: GetCommentsForUserResponse

Example

getCommentsForUser Esempio

Copy

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

addDomainConfig

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
addDomainConfigParams	AddDomainConfigParams	Sì

Risposta

Restituisce: AddDomainConfigResponse

Esempio

Esempio addDomainConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
AddDomainConfigParams params;
params.domain = U("example.com");
params.adminEmail = U("admin@example.com");
params.notes = boost::optional<utility::string_t>(U("Primary domain"));
api->addDomainConfig(tenantId, params).then([](pplx::task<std::shared_ptr<AddDomainConfigResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){
    }
});

deleteDomainConfig

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
domain	string	Sì

Risposta

Restituisce: DeleteDomainConfigResponse

Esempio

deleteDomainConfig Esempio

Copy

boost::optional<utility::string_t> optTenant = U("my-tenant-123");
boost::optional<utility::string_t> optDomain = U("example.com");
api->deleteDomainConfig(optTenant.value(), optDomain.value())
    .then([](pplx::task<std::shared_ptr<DeleteDomainConfigResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception&) {
        }
    });

getDomainConfig

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
domain	string	Sì

Risposta

Restituisce: GetDomainConfigResponse

Esempio

Esempio getDomainConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domain = U("myblog.example.com");
api->getDomainConfig(tenantId, domain)
    .then([](std::shared_ptr<GetDomainConfigResponse> response) {
        if (!response) return;
        boost::optional<bool> moderationEnabled = response->moderationEnabled;
        boost::optional<std::string> theme = response->theme;
        if (moderationEnabled && *moderationEnabled) {
            // gestire moderazione abilitata
        }
        if (theme) {
            // usa valore del tema
        }
    })
    .wait();

getDomainConfigs

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì

Risposta

Restituisce: GetDomainConfigsResponse

Esempio

Esempio getDomainConfigs

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> optionalTenant = tenantId;
api->getDomainConfigs(optionalTenant.value())
    .then([](std::shared_ptr<GetDomainConfigsResponse> response) {
        auto domains = response->getDomainList();
        for (const auto& d : domains) {
            std::cout << d << std::endl;
        }
    });

patchDomainConfig

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
domainToUpdate	string	Yes
patchDomainConfigParams	PatchDomainConfigParams	Yes

Risposta

Restituisce: PatchDomainConfigResponse

Esempio

Esempio patchDomainConfig

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto domainToUpdate = utility::conversions::to_string_t("example.com");
PatchDomainConfigParams patchDomainConfigParams;
patchDomainConfigParams.enableComments = boost::optional<bool>(true);
patchDomainConfigParams.moderationLevel = boost::optional<int>(2);
patchDomainConfigParams.customHeader = boost::optional<utility::string_t>(utility::conversions::to_string_t("X-Custom-Header"));
api->patchDomainConfig(tenantId, domainToUpdate, patchDomainConfigParams)
    .then([](std::shared_ptr<PatchDomainConfigResponse> resp) {
        // gestione del successo
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* gestione dell'errore */ }
    });

putDomainConfig

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
domainToUpdate	string	Sì
updateDomainConfigParams	UpdateDomainConfigParams	Sì

Risposta

Restituisce: PutDomainConfigResponse

Esempio

Esempio putDomainConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domainToUpdate = U("example.com");
UpdateDomainConfigParams updateParams;
updateParams.enableComments = true;
updateParams.moderationLevel = boost::optional<int>(2);
updateParams.customCss = boost::optional<utility::string_t>(U(".fc-comment{color:red;}"));
api->putDomainConfig(tenantId, domainToUpdate, updateParams)
    .then([](std::shared_ptr<PutDomainConfigResponse> resp) {
    });

createEmailTemplate

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
createEmailTemplateBody	CreateEmailTemplateBody	Sì

Risposta

Restituisce: CreateEmailTemplateResponse

Esempio

createEmailTemplate Esempio

Copy

auto body = std::make_shared<CreateEmailTemplateBody>();
body->subject = utility::string_t("Welcome Email");
body->htmlContent = utility::string_t("<h1>Welcome!</h1><p>Thanks for joining.</p>");
body->fromEmail = utility::string_t("no-reply@myapp.com");
body->replyTo = boost::optional<utility::string_t>(utility::string_t("support@myapp.com"));
body->cc = boost::none;
api->createEmailTemplate(utility::string_t("my-tenant-123"), *body)
    .then([](std::shared_ptr<CreateEmailTemplateResponse> resp) {
        std::cout << "Created template ID: " << resp->id << std::endl;
    });

deleteEmailTemplate

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Restituisce: APIEmptyResponse

Example

Esempio deleteEmailTemplate

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto templateId = utility::conversions::to_string_t("welcome-email-template");
boost::optional<utility::string_t> optTenantId = tenantId;
boost::optional<utility::string_t> optTemplateId = templateId;
api->deleteEmailTemplate(optTenantId.value(), optTemplateId.value())
    .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> t) {
        try { t.get(); }
        catch (const std::exception&) {}
    });

deleteEmailTemplateRenderError

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
errorId	string	Yes

Response

Restituisce: APIEmptyResponse

Esempio

deleteEmailTemplateRenderError Esempio

Copy

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

getEmailTemplate

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
id	string	Sì

Risposta

Restituisce: GetEmailTemplateResponse

Esempio

getEmailTemplate Esempio

Copy

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

getEmailTemplateDefinitions

Parametri

Name	Type	Required	Description
tenantId	string	Sì

Risposta

Restituisce: GetEmailTemplateDefinitionsResponse

Esempio

Esempio getEmailTemplateDefinitions

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
api->getEmailTemplateDefinitions(tenantId).then([](pplx::task<std::shared_ptr<GetEmailTemplateDefinitionsResponse>> t) {
    try {
        auto resp = t.get();
        boost::optional<utility::string_t> tmplName = resp ? resp->templateName : boost::none;
        if (tmplName) {
            std::cout << *tmplName << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
});

getEmailTemplateRenderErrors

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
skip	double	No

Risposta

Restituisce: GetEmailTemplateRenderErrorsResponse

Esempio

getEmailTemplateRenderErrors Esempio

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("email-template-789");
boost::optional<double> skip = 20.0;
api->getEmailTemplateRenderErrors(tenantId, id, skip)
    .then([](pplx::task<std::shared_ptr<GetEmailTemplateRenderErrorsResponse>> task) {
        try {
            auto response = task.get();
            // Usa la risposta come necessario
        } catch (const std::exception& ex) {
            // Gestisci l'errore
        }
    });

getEmailTemplates

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
skip	double	No

Risposta

Restituisce: GetEmailTemplatesResponse

Esempio

Esempio getEmailTemplates

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
boost::optional<double> skip = 10.0;
api->getEmailTemplates(tenantId, skip)
    .then([](std::shared_ptr<GetEmailTemplatesResponse> resp) {
        (void)resp;
    });

renderEmailTemplate

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
renderEmailTemplateBody	RenderEmailTemplateBody	Sì
locale	string	No

Risposta

Restituisce: RenderEmailTemplateResponse

Esempio

renderEmailTemplate Esempio

Copy

auto body = RenderEmailTemplateBody();
body.templateId = U("welcome-email");
body.recipientEmail = U("user@example.com");
boost::optional<utility::string_t> locale = U("en-US");
api->renderEmailTemplate(U("my-tenant-123"), body, locale)
    .then([](std::shared_ptr<RenderEmailTemplateResponse> resp) {
        std::cout << "Email template rendered successfully\n";
    });

updateEmailTemplate

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
id	string	Yes
updateEmailTemplateBody	UpdateEmailTemplateBody	Yes

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di updateEmailTemplate

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email");
UpdateEmailTemplateBody body;
body.subject = U("Welcome to Our Platform");
body.content = U("<p>Hello \{{userName}}, welcome aboard!</p>");
body.isActive = boost::optional<bool>(true);
api->updateEmailTemplate(tenantId, templateId, body)
    .then([](std::shared_ptr<APIEmptyResponse> response) {
        // gestione del successo
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception &) { /* gestione degli errori */ }
    });

getEventLog

req tenantId urlId userIdWS

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
urlId	string	Sì
userIdWS	string	Sì
startTime	int64_t	Sì
endTime	int64_t	No

Risposta

Restituisce: GetEventLogResponse

Esempio

Esempio getEventLog

Copy

auto startTime = int64_t(1622505600);
boost::optional<int64_t> endTime = int64_t(1622592000);
api->getEventLog(U("my-tenant-123"), U("article-456"), U("user@example.com"), startTime, endTime)
    .then([](std::shared_ptr<GetEventLogResponse> response){
        auto copy = std::make_shared<GetEventLogResponse>(*response);
        (void)copy;
    });

getGlobalEventLog

req tenantId urlId userIdWS

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
urlId	string	Yes
userIdWS	string	Yes
startTime	int64_t	Yes
endTime	int64_t	No

Risposta

Restituisce: GetEventLogResponse

Esempio

Esempio getGlobalEventLog

Copy

api->getGlobalEventLog(
    U("my-tenant-123"),
    U("article-456"),
    U("user@example.com"),
    1622505600,
    boost::optional<int64_t>(1625097600)
).then([](std::shared_ptr<GetEventLogResponse> resp) {
    (void)resp;
});

createFeedPost

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
createFeedPostParams	CreateFeedPostParams	Sì
options	const CreateFeedPostOptions&	Sì

Risposta

Restituisce: CreateFeedPostsResponse

Esempio

createFeedPost Esempio

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
CreateFeedPostParams postParams;
postParams.content = utility::conversions::to_string_t("Excited to join FastComments!");
postParams.authorEmail = utility::conversions::to_string_t("user@example.com");
postParams.title = utility::conversions::to_string_t("My First Post");
postParams.tags = boost::optional<std::vector<utility::string_t>>({ utility::conversions::to_string_t("intro") });
CreateFeedPostOptions options;
options.notifyFollowers = boost::optional<bool>(true);
options.scheduledAt = boost::optional<utility::datetime>(utility::datetime::utc_now());
api->createFeedPost(tenantId, postParams, options).then([](std::shared_ptr<CreateFeedPostsResponse> resp) {
    auto postId = resp->postId;
});

createFeedPostPublic

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
createFeedPostParams	CreateFeedPostParams	Sì
options	const CreateFeedPostPublicOptions&	Sì

Risposta

Restituisce: CreateFeedPostResponse

Esempio

Esempio createFeedPostPublic

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateFeedPostParams params;
params.title = U("Introducing Our New Feature");
params.content = U("We are excited to announce the release of our latest update.");
params.authorEmail = boost::optional<utility::string_t>(U("user@example.com"));
params.tags = boost::optional<std::vector<utility::string_t>>({U("announcement"), U("release")});
CreateFeedPostPublicOptions options;
api->createFeedPostPublic(tenantId, params, options)
    .then([](std::shared_ptr<CreateFeedPostResponse> resp) {
        if (resp) {
            std::wcout << U("Post created with ID: ") << resp->postId << std::endl;
        }
    });

deleteFeedPostPublic

Parametri

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

Risposta

Restituisce: DeleteFeedPostPublicResponse

Esempio

deleteFeedPostPublic Esempio

Copy

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

getFeedPosts

req tenantId afterId

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
options	const GetFeedPostsOptions&	Yes

Risposta

Restituisce: GetFeedPostsResponse

Esempio

Esempio getFeedPosts

Copy

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

getFeedPostsPublic

req
tenantId
afterId

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetFeedPostsPublicOptions&	Sì

Risposta

Restituisce: PublicFeedPostsResponse

Esempio

Esempio getFeedPostsPublic

Copy

  
auto options = GetFeedPostsPublicOptions{};  
options.limit = boost::optional<int>{20};  
options.before = boost::optional<utility::string_t>{U("2023-01-01T00:00:00Z")};  
api->getFeedPostsPublic(U("my-tenant-123"), options).then([](pplx::task<std::shared_ptr<PublicFeedPostsResponse>> task){  
    try{  
        auto response = task.get();  
        auto processed = std::make_shared<PublicFeedPostsResponse>(*response);  
        // Usa processed come necessario  
    }catch(const std::exception&){  
        // Gestisci l'errore  
    }  
});  

getFeedPostsStats

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
postIds	vector<string	Sì
sso	string	No

Risposta

Restituisce: FeedPostsStatsResponse

Esempio

Esempio getFeedPostsStats

Copy

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

getUserReactsPublic

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetUserReactsPublicOptions&	Sì

Risposta

Restituisce: UserReactsResponse

Esempio

getUserReactsPublic Esempio

Copy

auto options = GetUserReactsPublicOptions{};
options.userId = boost::optional<utility::string_t>(U("user@example.com"));
options.limit = boost::optional<int>(50);
api->getUserReactsPublic(U("my-tenant-123"), options).then([](pplx::task<std::shared_ptr<UserReactsResponse>> t){
    auto response = t.get();
});

reactFeedPostPublic

Parametri

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

Risposta

Restituisce: ReactFeedPostResponse

Esempio

reactFeedPostPublic Esempio

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto postId = utility::conversions::to_string_t("post-987");
ReactBodyParams reactBody;
reactBody.reaction = utility::conversions::to_string_t("love");
reactBody.userId = utility::conversions::to_string_t("user@example.com");
ReactFeedPostPublicOptions options;
options.metadata = boost::optional<utility::string_t>(utility::conversions::to_string_t("mobile"));
api->reactFeedPostPublic(tenantId, postId, reactBody, options)
    .then([](std::shared_ptr<ReactFeedPostResponse> resp) {
    });

updateFeedPost

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
feedPost	FeedPost	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio updateFeedPost

Copy

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

updateFeedPostPublic

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
postId	string	Sì
updateFeedPostParams	UpdateFeedPostParams	Sì
options	const UpdateFeedPostPublicOptions&	Sì

Risposta

Restituisce: CreateFeedPostResponse

Esempio

updateFeedPostPublic Esempio

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t postId = U("post-456");
UpdateFeedPostParams params;
params.title = boost::optional<utility::string_t>(U("Updated Title"));
params.body = boost::optional<utility::string_t>(U("Updated content of the post."));
UpdateFeedPostPublicOptions options;
options.notifyFollowers = boost::optional<bool>(true);
api->updateFeedPostPublic(tenantId, postId, params, options)
    .then([](std::shared_ptr<CreateFeedPostResponse> resp) {
        auto result = resp;
    });

flagCommentPublic

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
commentId	string	Yes
isFlagged	bool	Yes
sso	string	No

Risposta

Restituisce: APIEmptyResponse

Esempio

flagCommentPublic Esempio

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("cmt-456789");
bool isFlagged = true;
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("sso-token-abc");
api->flagCommentPublic(tenantId, commentId, isFlagged, sso)
    .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> t){
        try{
            auto resp = t.get();
        }catch(const std::exception&){
        }
    });

getGifLarge

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
largeInternalURLSanitized	string	Sì

Risposta

Restituisce: GifGetLargeResponse

Esempio

getGifLarge Esempio

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto largeUrl = utility::conversions::to_string_t("https://cdn.example.com/gifs/large/abc123.gif");
api->getGifLarge(tenantId, largeUrl)
   .then([&](std::shared_ptr<GifGetLargeResponse> resp) {
        boost::optional<utility::string_t> maybeUrl;
        if (resp && resp->url) {
            maybeUrl = resp->url;
        }
        if (maybeUrl) {
            std::wcout << *maybeUrl << std::endl;
        }
   });

getGifsSearch

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
search	string	Yes
options	const GetGifsSearchOptions&	Yes

Risposta

Restituisce: GetGifsSearchResponse

Esempio

Esempio getGifsSearch

Copy

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

getGifsTrending

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetGifsTrendingOptions&	Sì

Risposta

Restituisce: GetGifsTrendingResponse

Esempio

Esempio getGifsTrending

Copy

utility::string_t tenantId = U("my-tenant-123");
GetGifsTrendingOptions options;
options.limit = 10;
options.rating = boost::optional<utility::string_t>(U("G"));
api->getGifsTrending(tenantId, options).then([](std::shared_ptr<GetGifsTrendingResponse> response) {
    for (const auto& gif : response->gifs) {
        auto url = gif.url;
    }
});

addHashTag

Parametri

Name	Type	Required	Description
tenantId	string	Yes
createHashTagBody	CreateHashTagBody	Yes

Risposta

Restituisce: CreateHashTagResponse

Esempio

Esempio addHashTag

Copy

CreateHashTagBody request;
request.tag = utility::conversions::to_string_t("feature-request");
request.description = utility::conversions::to_string_t("Requests for new features");
request.relatedUrl = boost::optional<utility::string_t>(utility::conversions::to_string_t("https://example.com/feature-request"));
api->addHashTag(utility::conversions::to_string_t("my-tenant-123"), request)
    .then([](std::shared_ptr<CreateHashTagResponse> resp) {
        (void)resp;
    });

addHashTagsBulk

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Sì

Risposta

Restituisce: BulkCreateHashTagsResponse

Esempio

Esempio addHashTagsBulk

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
BulkCreateHashTagsBody bulkBody;
bulkBody.tags = { utility::string_t(U("announcement")), utility::string_t(U("feature-request")) };
bulkBody.description = boost::optional<utility::string_t>(U("Bulk tag creation"));
api->addHashTagsBulk(tenantId, bulkBody).then([](pplx::task<std::shared_ptr<BulkCreateHashTagsResponse>> task){
    try{
        auto resp = task.get();
    }catch(const std::exception&){
    }
});

deleteHashTag

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
tag	string	Sì
deleteHashTagRequestBody	DeleteHashTagRequestBody	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

deleteHashTag Esempio

Copy

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

getHashTags

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
page	double	No

Risposta

Restituisce: GetHashTagsResponse

Esempio

Esempio getHashTags

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
boost::optional<double> page = 2.0;
api->getHashTags(tenantId, page).then([](pplx::task<std::shared_ptr<GetHashTagsResponse>> task) {
    try {
        auto resultPtr = task.get();
        auto response = std::make_shared<GetHashTagsResponse>(*resultPtr);
        // usa la risposta
    } catch (const std::exception&) {
        // gestisci l'errore
    }
});

patchHashTag

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
tag	string	Yes
updateHashTagBody	UpdateHashTagBody	Yes

Risposta

Restituisce: UpdateHashTagResponse

Esempio

Esempio patchHashTag

Copy

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

deleteModerationVote

Parametri

Name	Type	Required
tenantId	string	Sì
commentId	string	Sì
voteId	string	Sì
options	const DeleteModerationVoteOptions&	Sì

Risposta

Restituisce: VoteDeleteResponse

Esempio

Esempio deleteModerationVote

Copy

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

getApiComments

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
options	const GetApiCommentsOptions&	Yes

Risposta

Restituisce: ModerationAPIGetCommentsResponse

Esempio

Esempio getApiComments

Copy

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

getApiExportStatus

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetApiExportStatusOptions&	Sì

Risposta

Restituisce: ModerationExportStatusResponse

Esempio

Esempio getApiExportStatus

Copy

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

getApiIds

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetApiIdsOptions&	Sì

Risposta

Restituisce: ModerationAPIGetCommentIdsResponse

Esempio

getApiIds Esempio

Copy

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

getBanUsersFromComment

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
sso	string	No

Risposta

Restituisce: GetBannedUsersFromCommentResponse

Esempio

getBanUsersFromComment Esempio

Copy

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

getCommentBanStatus

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
sso	string	No

Risposta

Restituisce: GetCommentBanStatusResponse

Esempio

getCommentBanStatus Esempio

Copy

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

getCommentChildren

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
sso	string	No

Risposta

Restituisce: ModerationAPIChildCommentsResponse

Esempio

Esempio getCommentChildren

Copy

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

getCount

Parametri

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

Risposta

Restituisce: ModerationAPICountCommentsResponse

Esempio

Esempio getCount

Copy

utility::string_t tenantId = U("my-tenant-123");
GetCountOptions options;
options.userEmail = boost::optional<utility::string_t>(U("user@example.com"));
options.maxResults = boost::optional<int>(100);
api->getCount(tenantId, options).then([](pplx::task<std::shared_ptr<ModerationAPICountCommentsResponse>> task){
    try{
        auto resp = task.get();
        auto copy = std::make_shared<ModerationAPICountCommentsResponse>(*resp);
        std::cout << "Count: " << copy->count << std::endl;
    }catch(const std::exception& e){
        std::cerr << "Error: " << e.what() << std::endl;
    }
});

getCounts

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
sso	string	No

Risposta

Restituisce: GetBannedUsersCountResponse

Esempio

Esempio getCounts

Copy

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

getLogs

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
sso	string	No

Risposta

Restituisce: ModerationAPIGetLogsResponse

Esempio

Esempio getLogs

Copy

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

getManualBadges

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
sso	string	No

Risposta

Restituisce: GetTenantManualBadgesResponse

Esempio

Esempio getManualBadges

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> sso = boost::make_optional(U("user@example.com"));
api->getManualBadges(tenantId, sso)
    .then([](pplx::task<std::shared_ptr<GetTenantManualBadgesResponse>> t) {
        try {
            auto response = t.get();
            // elabora la risposta, es., response->badgeList
        } catch (const std::exception& ex) {
            // gestisci l'errore
        }
    });

getManualBadgesForUser

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetManualBadgesForUserOptions&	Sì

Risposta

Restituisce: GetUserManualBadgesResponse

Esempio

Esempio getManualBadgesForUser

Copy

utility::string_t tenantId = U("my-tenant-123");
GetManualBadgesForUserOptions options;
options.userEmail = boost::optional<utility::string_t>(U("user@example.com"));
options.includeInactive = boost::optional<bool>(true);
api->getManualBadgesForUser(tenantId, options).then([](pplx::task<std::shared_ptr<GetUserManualBadgesResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){
    }
});

getModerationComment

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
commentId	string	Yes
options	const GetModerationCommentOptions&	Yes

Risposta

Restituisce: ModerationAPICommentResponse

Esempio

Esempio getModerationComment

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-456");
GetModerationCommentOptions options;
options.includeDeleted = boost::optional<bool>(true);
options.locale = boost::optional<utility::string_t>(utility::conversions::to_string_t("en-US"));
api->getModerationComment(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<ModerationAPICommentResponse>> task) {
        try {
            auto response = task.get();
            // Elabora la risposta secondo necessità
        } catch (const std::exception& ex) {
            // Gestisci l'errore
        }
    });

getModerationCommentText

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Risposta

Restituisce: GetCommentTextResponse

Esempio

Esempio getModerationCommentText

Copy

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

getPreBanSummary

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
options	const GetPreBanSummaryOptions&	Sì

Risposta

Restituisce: PreBanSummary

Esempio

Esempio getPreBanSummary

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("cmt-456789");
GetPreBanSummaryOptions options;
options.locale = boost::optional<utility::string_t>{utility::conversions::to_string_t("en-US")};
api->getPreBanSummary(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<PreBanSummary>> t) {
        try {
            auto summary = t.get();
            // processa il riepilogo
        } catch (const std::exception&) {
            // gestisci l'errore
        }
    });

getSearchCommentsSummary

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetSearchCommentsSummaryOptions&	Sì

Risposta

Restituisce: ModerationCommentSearchResponse

Esempio

Esempio getSearchCommentsSummary

Copy

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

getSearchPages

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetSearchPagesOptions&	Sì

Risposta

Restituisce: ModerationPageSearchResponse

Esempio

Esempio di getSearchPages

Copy

GetSearchPagesOptions options;
options.pageNumber = boost::optional<int>(1);
options.pageSize = boost::optional<int>(50);
options.searchTerm = boost::optional<utility::string_t>(U("spam"));
api->getSearchPages(U("my-tenant-123"), options)
    .then([](pplx::task<std::shared_ptr<ModerationPageSearchResponse>> task) {
        try {
            auto response = task.get();
            // usa la risposta
        } catch (const std::exception& e) {
            // gestire l'errore
        }
    });

getSearchSites

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetSearchSitesOptions&	Sì

Risposta

Restituisce: ModerationSiteSearchResponse

Esempio

getSearchSites Esempio

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
GetSearchSitesOptions options;
options.query = boost::make_optional(utility::string_t(U("example query")));
options.limit = boost::make_optional(25);
api->getSearchSites(tenantId, options)
   .then([](pplx::task<std::shared_ptr<ModerationSiteSearchResponse>> t) {
       try {
           auto response = t.get();
           auto respPtr = std::make_shared<ModerationSiteSearchResponse>(*response);
           for (const auto& site : respPtr->sites) {
               // logica di elaborazione
           }
       } catch (const std::exception&) {
           // gestione degli errori
       }
   });

getSearchSuggest

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetSearchSuggestOptions&	Sì

Risposta

Restituisce: ModerationSuggestResponse

Esempio

Esempio getSearchSuggest

Copy

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

getSearchUsers

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetSearchUsersOptions&	Sì

Risposta

Restituisce: ModerationUserSearchResponse

Esempio

Esempio getSearchUsers

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
GetSearchUsersOptions opts;
opts.query = utility::string_t(U("john.doe@example.com"));
opts.page = boost::optional<int>(1);
opts.pageSize = boost::optional<int>(20);
api->getSearchUsers(tenantId, opts)
    .then([](std::shared_ptr<ModerationUserSearchResponse> resp) {
        for (const auto& user : resp->users) {
            std::wcout << user.id << L" - " << user.email << std::endl;
        }
    });

getTrustFactor

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetTrustFactorOptions&	Sì

Risposta

Restituisce: GetUserTrustFactorResponse

Esempio

Esempio getTrustFactor

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
GetTrustFactorOptions options;
options.userEmail = boost::optional<utility::string_t>(U("user@example.com"));
options.ipAddress = boost::optional<utility::string_t>(U("203.0.113.42"));
api->getTrustFactor(tenantId, options).then([](std::shared_ptr<GetUserTrustFactorResponse> resp) {
    if (resp) {
        std::cout << "Trust factor: " << resp->trustFactor << std::endl;
    }
});

getUserBanPreference

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
sso	string	No

Risposta

Restituisce: APIModerateGetUserBanPreferencesResponse

Esempio

Esempio getUserBanPreference

Copy

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

getUserInternalProfile

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
options	const GetUserInternalProfileOptions&	Yes

Risposta

Restituisce: GetUserInternalProfileResponse

Esempio

Esempio getUserInternalProfile

Copy

utility::string_t tenantId = U("my-tenant-123");
GetUserInternalProfileOptions options;
options.email = boost::optional<utility::string_t>(U("user@example.com"));
options.includeDetails = boost::optional<bool>(true);
api->getUserInternalProfile(tenantId, options)
    .then([](std::shared_ptr<GetUserInternalProfileResponse> response) {
        if (response) {
            auto name = response->displayName;
            auto id = response->userId;
        }
    });

postAdjustCommentVotes

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
commentId	string	Yes
adjustCommentVotesParams	AdjustCommentVotesParams	Yes
options	const PostAdjustCommentVotesOptions&	Yes

Risposta

Restituisce: AdjustVotesResponse

Esempio

Esempio di postAdjustCommentVotes

Copy

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

postApiExport

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
options	const PostApiExportOptions&	Yes

Risposta

Restituisce: ModerationExportResponse

Esempio

Esempio postApiExport

Copy

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

postBanUserFromComment

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
commentId	string	Yes
options	const PostBanUserFromCommentOptions&	Yes

Risposta

Restituisce: BanUserFromCommentResult

Esempio

postBanUserFromComment Esempio

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("comment-456789");
PostBanUserFromCommentOptions options;
options.reason = boost::optional<utility::string_t>(U("spam"));
options.durationDays = boost::optional<int>(30);
api->postBanUserFromComment(tenantId, commentId, options)
    .then([](std::shared_ptr<BanUserFromCommentResult> result) {
        // gestione del risultato
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* gestione dell'errore */ }
    });

postBanUserUndo

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
banUserUndoParams	BanUserUndoParams	Sì
sso	string	No

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio postBanUserUndo

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
BanUserUndoParams banParams;
banParams.userId = utility::string_t(U("user-567"));
banParams.reason = utility::string_t(U("reinstated"));
boost::optional<utility::string_t> sso = utility::string_t(U("sso-token-abc"));
api->postBanUserUndo(tenantId, banParams, sso).then([](std::shared_ptr<APIEmptyResponse> resp){
    // gestisci il successo
});

postBulkPreBanSummary

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
bulkPreBanParams	BulkPreBanParams	Sì
options	const PostBulkPreBanSummaryOptions&	Sì

Risposta

Restituisce: BulkPreBanSummary

Esempio

Esempio postBulkPreBanSummary

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
BulkPreBanParams bulkPreBanParams;
bulkPreBanParams.emails = {
    utility::conversions::to_string_t("spam1@example.com"),
    utility::conversions::to_string_t("spam2@example.com")
};
bulkPreBanParams.reason = utility::conversions::to_string_t("spam");
PostBulkPreBanSummaryOptions options;
options.requestId = boost::optional<utility::string_t>(utility::conversions::to_string_t("req-456"));
api->postBulkPreBanSummary(tenantId, bulkPreBanParams, options)
    .then([](std::shared_ptr<BulkPreBanSummary> result) {
        (void)result;
    });

postCommentsByIds

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
commentsByIdsParams	CommentsByIdsParams	Yes
sso	string	No

Risposta

Restituisce: ModerationAPIChildCommentsResponse

Esempio

Esempio postCommentsByIds

Copy

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

postFlagComment

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
options	const PostFlagCommentOptions&	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio postFlagComment

Copy

PostFlagCommentOptions options;
options.reason = boost::optional<utility::string_t>(U("spam"));
options.reportedBy = boost::optional<utility::string_t>(U("moderator@example.com"));
api->postFlagComment(U("my-tenant-123"), U("comment-456"), options)
    .then([](std::shared_ptr<APIEmptyResponse> resp){
        (void)resp;
    })
    .then([](pplx::task<void> t){
        try{
            t.get();
        }catch(const std::exception&){
        }
    });

postRemoveComment

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
options	const PostRemoveCommentOptions&	Sì

Risposta

Restituisce: PostRemoveCommentApiResponse

Esempio

Esempio postRemoveComment

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto commentId = utility::string_t(U("cmt-456789"));
PostRemoveCommentOptions options;
options.permanent = boost::optional<bool>(true);
api->postRemoveComment(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<PostRemoveCommentApiResponse>> task) {
        try {
            auto response = task.get();
            // Elabora la risposta
        } catch (const std::exception& ex) {
            // Gestisci l'errore
        }
    });

postRestoreDeletedComment

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
commentId	string	Yes
options	const PostRestoreDeletedCommentOptions&	Yes

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio postRestoreDeletedComment

Copy

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

postSetCommentApprovalStatus

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentApprovalStatusOptions&	Yes

Risposta

Restituisce: SetCommentApprovedResponse

Esempio

postSetCommentApprovalStatus Esempio

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-abc123");
auto options = std::make_shared<PostSetCommentApprovalStatusOptions>();
options->approved = boost::optional<bool>(true);
options->reason = boost::optional<utility::string_t>(utility::conversions::to_string_t("Inappropriate content"));
api->postSetCommentApprovalStatus(tenantId, commentId, *options)
    .then([](pplx::task<std::shared_ptr<SetCommentApprovedResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception& ex) {
        }
    });

postSetCommentReviewStatus

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
options	const PostSetCommentReviewStatusOptions&	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

postSetCommentReviewStatus Esempio

Copy

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

postSetCommentSpamStatus

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
options	const PostSetCommentSpamStatusOptions&	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

postSetCommentSpamStatus Esempio

Copy

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

postSetCommentText

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
setCommentTextParams	SetCommentTextParams	Sì
options	const PostSetCommentTextOptions&	Sì

Risposta

Restituisce: SetCommentTextResponse

Esempio

Esempio postSetCommentText

Copy

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

postUnFlagComment

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
options	const PostUnFlagCommentOptions&	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

postUnFlagComment Esempio

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
PostUnFlagCommentOptions opts;
opts.notifyUser = boost::optional<bool>(true);
api->postUnFlagComment(tenantId, commentId, opts)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // l'elaborazione può essere eseguita qui
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

postVote

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
options	const PostVoteOptions&	Sì

Risposta

Restituisce: VoteResponse

Esempio

postVote Esempio

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
PostVoteOptions options;
options.upvote = boost::make_optional(true);
options.reason = boost::make_optional<std::string>("Inappropriate content");
api->postVote(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<VoteResponse>> t) {
        try {
            auto resp = t.get();
            auto count = resp->voteCount;
        } catch (const std::exception& e) {
        }
    });

putAwardBadge

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
badgeId	string	Sì
options	const PutAwardBadgeOptions&	Sì

Risposta

Restituisce: AwardUserBadgeResponse

Esempio

putAwardBadge Esempio

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto badgeId = utility::conversions::to_string_t("badge-456");
PutAwardBadgeOptions opts;
opts.userId = utility::conversions::to_string_t("user-42");
opts.note = boost::optional<utility::string_t>(utility::conversions::to_string_t("Excellent comment"));
api->putAwardBadge(tenantId, badgeId, opts).then([](pplx::task<std::shared_ptr<AwardUserBadgeResponse>> t){
    try{
        auto resp = t.get();
        auto respCopy = std::make_shared<AwardUserBadgeResponse>(*resp);
    }catch(const std::exception& e){
    }
});

putCloseThread

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
urlId	string	Sì
sso	string	No

Risposta

Restituisce: APIEmptyResponse

Esempio

putCloseThread Esempio

Copy

auto tenantId = utility::string_t(U("my-tenant-4321"));
auto urlId = utility::string_t(U("article-9876"));
boost::optional<utility::string_t> sso = boost::make_optional<utility::string_t>(U("user@example.com"));
api->putCloseThread(tenantId, urlId, sso).then([](pplx::task<std::shared_ptr<APIEmptyResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){
    }
});

putRemoveBadge

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
badgeId	string	Sì
options	const PutRemoveBadgeOptions&	Sì

Risposta

Restituisce: RemoveUserBadgeResponse

Esempio

Esempio putRemoveBadge

Copy

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

putReopenThread

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
urlId	string	Sì
sso	string	No

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio putReopenThread

Copy

api->putReopenThread(utility::string_t(U("my-tenant-123")), utility::string_t(U("thread-456")), boost::make_optional<utility::string_t>(U("user@example.com")))
    .then([](std::shared_ptr<APIEmptyResponse> result){
        std::cout << "Thread reopened" << std::endl;
    });

setTrustFactor

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const SetTrustFactorOptions&	Sì

Risposta

Restituisce: SetUserTrustFactorResponse

Esempio

Esempio setTrustFactor

Copy

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

createModerator

Parametri

Name	Type	Required	Description
tenantId	string	Yes
createModeratorBody	CreateModeratorBody	Yes

Risposta

Restituisce: CreateModeratorResponse

Esempio

Esempio createModerator

Copy

CreateModeratorBody moderatorBody;
moderatorBody.email = utility::conversions::to_string_t("moderator@example.com");
moderatorBody.name = utility::conversions::to_string_t("John Moderator");
moderatorBody.notes = boost::optional<utility::string_t>(utility::conversions::to_string_t("Community moderator"));
api->createModerator(utility::conversions::to_string_t("my-tenant-123"), moderatorBody)
    .then([](std::shared_ptr<CreateModeratorResponse> resp) {});

deleteModerator

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
sendEmail	string	No

Risposta

Restituisce: APIEmptyResponse

Esempio

deleteModerator Esempio

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto moderatorId = utility::conversions::to_string_t("mod-456");
boost::optional<utility::string_t> sendEmail = utility::conversions::to_string_t("admin@example.com");
api->deleteModerator(tenantId, moderatorId, sendEmail)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // gestisci il successo
    });

getModerator

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
id	string	Sì

Risposta

Restituisce: GetModeratorResponse

Esempio

Esempio getModerator

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto moderatorId = utility::string_t(U("moderator-789"));
api->getModerator(tenantId, moderatorId)
    .then([](pplx::task<std::shared_ptr<GetModeratorResponse>> t) {
        try {
            auto response = t.get();
        } catch (const std::exception&) {
        }
    });

getModerators

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
skip	double	No

Risposta

Restituisce: GetModeratorsResponse

Esempio

Esempio getModerators

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = 10.0;
api->getModerators(tenantId, skip).then([](pplx::task<std::shared_ptr<GetModeratorsResponse>> t){
    auto response = t.get();
});

sendInvite

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
fromName	string	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio sendInvite

Copy

boost::optional<utility::string_t> cc = utility::conversions::to_string_t("cc@example.com");
api->sendInvite(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("invitee@example.com"),
    utility::conversions::to_string_t("John Doe")
).then([](std::shared_ptr<APIEmptyResponse> resp) {
    // gestire l'invito con successo
});

updateModerator

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
updateModeratorBody	UpdateModeratorBody	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio updateModerator

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto moderatorId = utility::conversions::to_string_t("mod-789");
UpdateModeratorBody body;
body.email = utility::conversions::to_string_t("moderator@example.com");
body.isActive = true;
body.notes = boost::optional<utility::string_t>(utility::conversions::to_string_t("Senior moderator"));
api->updateModerator(tenantId, moderatorId, body)
    .then([](std::shared_ptr<APIEmptyResponse>) {})
    .then([](pplx::task<void> t) { try { t.get(); } catch (const std::exception&) {} });

deleteNotificationCount

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
id	string	Sì

Risposta

Ritorna: APIEmptyResponse

Esempio

Esempio di deleteNotificationCount

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto notificationId = utility::conversions::to_string_t("notif-789");
api->deleteNotificationCount(tenantId, notificationId)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {})
    .then([](pplx::task<void> t) { try { t.get(); } catch (const std::exception&) {} });

getCachedNotificationCount

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
id	string	Sì

Risposta

Restituisce: GetCachedNotificationCountResponse

Esempio

Esempio getCachedNotificationCount

Copy

auto tenantId = boost::optional<utility::string_t>(utility::conversions::to_string_t("my-tenant-123"));
auto userId = boost::optional<utility::string_t>(utility::conversions::to_string_t("user-456"));
api->getCachedNotificationCount(tenantId.value(), userId.value())
    .then([](pplx::task<std::shared_ptr<GetCachedNotificationCountResponse>> task) {
        try {
            auto response = task.get();
            // processare la risposta
        } catch (const std::exception&) {
            // gestire l'errore
        }
    });

getNotificationCount

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetNotificationCountOptions&	Sì

Risposta

Restituisce: GetNotificationCountResponse

Esempio

Esempio getNotificationCount

Copy

auto tenantId = U("my-tenant-123");
GetNotificationCountOptions options;
options.filter = boost::optional<utility::string_t>(U("unread"));
options.maxCount = boost::optional<int>(10);
api->getNotificationCount(tenantId, options)
    .then([](pplx::task<std::shared_ptr<GetNotificationCountResponse>> t) {
        try {
            auto response = t.get();
        } catch (const std::exception& ex) {
        }
    });

getNotifications

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetNotificationsOptions&	Sì

Risposta

Restituisce: GetNotificationsResponse

Esempio

Esempio getNotifications

Copy

GetNotificationsOptions options;
options.limit = 20;
options.after = U("cursor-123");
api->getNotifications(U("my-tenant-123"), options)
    .then([](std::shared_ptr<GetNotificationsResponse> resp) {
        (void)resp;
    });

updateNotification

Parametri

Name	Type	Required
tenantId	string	Sì
id	string	Sì
updateNotificationBody	UpdateNotificationBody	Sì
userId	string	No

Risposta

Returns: APIEmptyResponse

Esempio

Esempio di updateNotification

Copy

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

createV1PageReact

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
urlId	string	Sì
title	string	No

Risposta

Restituisce: CreateV1PageReact

Esempio

Esempio createV1PageReact

Copy

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

createV2PageReact

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
urlId	string	Sì
id	string	Sì
title	string	No

Risposta

Restituisce: CreateV1PageReact

Esempio

Esempio createV2PageReact

Copy

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

deleteV1PageReact

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
urlId	string	Sì

Risposta

Restituisce: CreateV1PageReact

Esempio

deleteV1PageReact Esempio

Copy

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

deleteV2PageReact

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
urlId	string	Sì
id	string	Sì

Risposta

Restituisce: CreateV1PageReact

Esempio

Esempio deleteV2PageReact

Copy

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

getV1PageLikes

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
urlId	string	Sì

Risposta

Restituisce: GetV1PageLikes

Esempio

Esempio getV1PageLikes

Copy

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

getV2PageReacts

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
urlId	string	Yes

Risposta

Restituisce: GetV2PageReacts

Esempio

Esempio getV2PageReacts

Copy

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

getV2PageReactUsers

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
urlId	string	Sì
id	string	Sì

Risposta

Restituisce: GetV2PageReactUsersResponse

Esempio

Esempio getV2PageReactUsers

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto urlId = utility::conversions::to_string_t("page-456");
auto id = utility::conversions::to_string_t("react-789");
boost::optional<utility::string_t> maybeFilter;
api->getV2PageReactUsers(tenantId, urlId, id).then([](pplx::task<std::shared_ptr<GetV2PageReactUsersResponse>> task){
    try{
        auto response = task.get();
        // Usa la risposta come necessario
    }catch(const std::exception&){
        // Gestisci l'errore
    }
});

addPage

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
createAPIPageData	CreateAPIPageData	Sì

Risposta

Restituisce: AddPageAPIResponse

Esempio

Esempio addPage

Copy

auto createData = CreateAPIPageData{};
createData.title = utility::string_t(U("Welcome Page"));
createData.url = utility::string_t(U("https://example.com/welcome"));
createData.description = boost::optional<utility::string_t>(utility::string_t(U("Landing page for new users")));
api->addPage(utility::string_t(U("my-tenant-123")), createData)
    .then([](std::shared_ptr<AddPageAPIResponse> response) {
        if (response && response->success) {
            // gestire l'aggiunta riuscita
        } else {
            // gestire l'errore
        }
    });

deletePage

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
id	string	Sì

Risposta

Restituisce: DeletePageAPIResponse

Esempio

deletePage Esempio

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto pageId   = utility::conversions::to_string_t("page-456");
api->deletePage(tenantId, pageId)
   .then([](pplx::task<std::shared_ptr<DeletePageAPIResponse>> t) {
       try {
           auto response = t.get();
           // elaborare la risposta se necessario
       } catch (const std::exception& ex) {
           // gestire l'errore
       }
   });

getOfflineUsers

Past commentatori sulla pagina che NON sono attualmente online. Ordinati per displayName.
Usa questo dopo aver esaurito /users/online per renderizzare una sezione "Members".
Paginazione con cursore su commenterName: il server percorre il parziale {tenantId, urlId, commenterName} indice da afterName in avanti tramite $gt, senza costo $skip.

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
urlId	string	Yes
options	const GetOfflineUsersOptions&	Yes

Risposta

Restituisce: PageUsersOfflineResponse

Esempio

Esempio getOfflineUsers

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("page-456");
GetOfflineUsersOptions options;
options.limit = boost::optional<int>(50);
options.includeDetails = boost::optional<bool>(true);
api->getOfflineUsers(tenantId, urlId, options)
    .then([](pplx::task<std::shared_ptr<PageUsersOfflineResponse>> t) {
        try {
            auto response = t.get();
        } catch (const std::exception&) {
        }
    });

getOnlineUsers

Visualizzatori attualmente online di una pagina: persone la cui sessione WebSocket è attualmente sottoscritta alla pagina. Restituisce anonCount + totalCount (abbonati a livello di stanza, inclusi gli spettatori anonimi che non enumeriamo).

Parameters

Nome	Tipo	Obbligatorio
tenantId	string	Yes
urlId	string	Yes
options	const GetOnlineUsersOptions&	Yes

Response

Restituisce: PageUsersOnlineResponse

Example

Esempio getOnlineUsers

Copy

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

getPageByURLId

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
urlId	string	Sì

Risposta

Restituisce: GetPageByURLIdAPIResponse

Esempio

getPageByURLId Esempio

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto urlId = utility::conversions::to_string_t("page-456");
boost::optional<utility::string_t> correlationId = boost::make_optional(utility::conversions::to_string_t("corr-789"));
api->getPageByURLId(tenantId, urlId)
    .then([correlationId](pplx::task<std::shared_ptr<GetPageByURLIdAPIResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception&) {
        }
    });

getPages

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì

Risposta

Restituisce: GetPagesAPIResponse

Esempio

getPages Esempio

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
api->getPages(tenantId)
    .then([](pplx::task<std::shared_ptr<GetPagesAPIResponse>> task) {
        try {
            auto response = task.get();
            boost::optional<utility::string_t> nextCursor = response->nextCursor;
        } catch (const std::exception&) {
        }
    });

getPagesPublic

Elenca le pagine per un tenant. Utilizzato dal client desktop FChat per popolare l'elenco delle sue stanze.
Richiede che enableFChat sia impostato su true nella configurazione personalizzata risolta per ogni pagina.
Le pagine che richiedono SSO sono filtrate in base all'accesso al gruppo dell'utente richiedente.

Parameters

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
options	const GetPagesPublicOptions&	Yes

Response

Restituisce: GetPublicPagesResponse

Example

Esempio getPagesPublic

Copy

utility::string_t tenantId = U("my-tenant-123");
GetPagesPublicOptions options;
options.limit = boost::optional<int>(50);
options.cursor = boost::optional<utility::string_t>(U("cursor-token"));
api->getPagesPublic(tenantId, options).then([](pplx::task<std::shared_ptr<GetPublicPagesResponse>> task){
    try{
        auto response = task.get();
        // elabora la risposta se necessario
    }catch(const std::exception&){
        // gestisci l'errore se necessario
    }
});

getUsersInfo

Informazioni utente in blocco per un tenant. Dati gli userIds, restituisce le informazioni da visualizzare da User / SSOUser.
Utilizzato dal widget dei commenti per arricchire gli utenti appena comparsi tramite un evento di presenza.
Nessun contesto di pagina: la privacy è applicata uniformemente (i profili privati sono mascherati).

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
ids	string	Yes

Risposta

Restituisce: PageUsersInfoResponse

Esempio

getUsersInfo Esempio

Copy

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

patchPage

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
updateAPIPageData	UpdateAPIPageData	Sì

Risposta

Restituisce: PatchPageAPIResponse

Esempio

patchPage Esempio

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t pageId = U("page-789");
UpdateAPIPageData update;
update.title = boost::optional<utility::string_t>(U("Updated Page Title"));
update.metadata = boost::optional<utility::string_t>(U("{\"author\":\"jane.doe@example.com\"}"));
api->patchPage(tenantId, pageId, update)
    .then([](std::shared_ptr<PatchPageAPIResponse> response) {
        if (response && response->isSuccess) {
            // gestire il successo
        }
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

deletePendingWebhookEvent

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
id	string	Yes

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di deletePendingWebhookEvent

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto eventId = utility::conversions::to_string_t("event-987654");
boost::optional<utility::string_t> optTenant = tenantId;
api->deletePendingWebhookEvent(optTenant.value(), eventId)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        (void)resp;
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { }
    });

getPendingWebhookEventCount

Parametri

Nome	Tipo	Richiesto	Descrizione
tenantId	string	Sì
options	const GetPendingWebhookEventCountOptions&	Sì

Risposta

Restituisce: GetPendingWebhookEventCountResponse

Esempio

getPendingWebhookEventCount Esempio

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
GetPendingWebhookEventCountOptions opts;
opts.filter = boost::optional<utility::string_t>(utility::conversions::to_string_t("active"));
api->getPendingWebhookEventCount(tenantId, opts)
    .then([](std::shared_ptr<GetPendingWebhookEventCountResponse> resp){
        auto count = resp->getCount();
    });

getPendingWebhookEvents

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
options	const GetPendingWebhookEventsOptions&	Yes

Risposta

Restituisce: GetPendingWebhookEventsResponse

Esempio

Esempio getPendingWebhookEvents

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
GetPendingWebhookEventsOptions opts;
opts.pageSize = boost::optional<int>(100);
opts.startAfter = boost::optional<utility::string_t>(U("event-abc-456"));
api->getPendingWebhookEvents(tenantId, opts)
    .then([](pplx::task<std::shared_ptr<GetPendingWebhookEventsResponse>> task) {
        try {
            auto resp = task.get();
            auto copy = std::make_shared<GetPendingWebhookEventsResponse>(*resp);
        } catch (const std::exception&) {}
    });

createQuestionConfig

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
createQuestionConfigBody	CreateQuestionConfigBody	Sì

Risposta

Restituisce: CreateQuestionConfigResponse

Esempio

createQuestionConfig Esempio

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
CreateQuestionConfigBody configBody;
configBody.question = utility::string_t(U("How satisfied are you with our service?"));
configBody.required = true;
configBody.defaultAnswer = boost::optional<utility::string_t>(utility::string_t(U("Very satisfied")));
api->createQuestionConfig(tenantId, configBody).then([](pplx::task<std::shared_ptr<CreateQuestionConfigResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){}
});

deleteQuestionConfig

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
id	string	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di deleteQuestionConfig

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto configId = utility::conversions::to_string_t("question-config-456");
api->deleteQuestionConfig(tenantId, configId)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // gestire l'eliminazione riuscita
    })
    .then([](pplx::task<void> t) {
        try {
            t.get();
        } catch (const std::exception&) {
            // gestire l'errore
        }
    });

getQuestionConfig

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
id	string	Sì

Risposta

Restituisce: GetQuestionConfigResponse

Esempio

Esempio getQuestionConfig

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto questionId = utility::conversions::to_string_t("question-456");
api->getQuestionConfig(tenantId, questionId)
    .then([](pplx::task<std::shared_ptr<GetQuestionConfigResponse>> task) {
        try {
            auto response = task.get();
            // Usa la risposta secondo necessità
        } catch (const std::exception&) {
            // Gestisci l'errore
        }
    });

getQuestionConfigs

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
skip	double	No

Risposta

Restituisce: GetQuestionConfigsResponse

Esempio

Esempio getQuestionConfigs

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<double> skip = 10.0;
api->getQuestionConfigs(tenantId, skip).then([](std::shared_ptr<GetQuestionConfigsResponse> resp){
    auto config = std::make_shared<GetQuestionConfigsResponse>(*resp);
});

updateQuestionConfig

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
updateQuestionConfigBody	UpdateQuestionConfigBody	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio updateQuestionConfig

Copy

UpdateQuestionConfigBody updateBody;
updateBody.enabled = true;
updateBody.maxResponses = boost::optional<int>{10};
updateBody.notes = boost::optional<utility::string_t>{U("Config updated via SDK")};
api->updateQuestionConfig(U("my-tenant-123"), U("config-789"), updateBody)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

createQuestionResult

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
createQuestionResultBody	CreateQuestionResultBody	Sì

Risposta

Restituisce: CreateQuestionResultResponse

Esempio

Esempio createQuestionResult

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateQuestionResultBody body;
body.questionId = U("question-456");
body.result = U("approved");
body.comment = boost::optional<utility::string_t>(U("Looks good"));
api->createQuestionResult(tenantId, body)
    .then([=](pplx::task<std::shared_ptr<CreateQuestionResultResponse>> t) {
        try {
            auto resp = t.get();
        } catch (const std::exception&) {
        }
    });

deleteQuestionResult

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
id	string	Yes

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di deleteQuestionResult

Copy

boost::optional<utility::string_t> optTenant = utility::conversions::to_string_t( "my-tenant-123" );
utility::string_t questionId = utility::conversions::to_string_t( "question-456" );
if ( optTenant )
{
    api->deleteQuestionResult( *optTenant, questionId )
        .then( []( pplx::task<std::shared_ptr<APIEmptyResponse>> t )
        {
            try
            {
                auto resp = t.get();
                // gestione del successo
            }
            catch ( const std::exception& e )
            {
                // gestione dell'errore
            }
        } );
}

getQuestionResult

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
id	string	Yes

Risposta

Returns: GetQuestionResultResponse

Esempio

Esempio getQuestionResult

Copy

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

getQuestionResults

Parameters

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

Response

Restituisce: GetQuestionResultsResponse

Example

Esempio getQuestionResults

Copy

utility::string_t tenantId = U("my-tenant-123");
GetQuestionResultsOptions options;
options.questionId = boost::optional<utility::string_t>(U("question-456"));
options.includeDeleted = boost::optional<bool>(false);
api->getQuestionResults(tenantId, options)
    .then([](pplx::task<std::shared_ptr<GetQuestionResultsResponse>> t) {
        auto response = t.get();
        // gestire la risposta
    });

updateQuestionResult

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
updateQuestionResultBody	UpdateQuestionResultBody	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

updateQuestionResult Esempio

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto questionId = utility::string_t(U("question-456"));
UpdateQuestionResultBody body;
body.result = U("approved");
body.note = boost::optional<utility::string_t>(U("Reviewed by admin"));
api->updateQuestionResult(tenantId, questionId, body)
    .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> t) {
        try {
            auto respPtr = std::make_shared<APIEmptyResponse>(*t.get());
        } catch (const std::exception&) {
        }
    });

aggregateQuestionResults

Parameters

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
options	const AggregateQuestionResultsOptions&	Yes

Risposta

Restituisce: AggregateQuestionResultsResponse

Esempio

Esempio di aggregateQuestionResults

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
AggregateQuestionResultsOptions opts;
opts.questionId = utility::conversions::to_string_t("question-789");
opts.startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-01T00:00:00Z"), utility::datetime::ISO_8601));
opts.endDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-31T23:59:59Z"), utility::datetime::ISO_8601));
api->aggregateQuestionResults(tenantId, opts)
    .then([](std::shared_ptr<AggregateQuestionResultsResponse> resp) {
        static_cast<void>(resp);
    });

bulkAggregateQuestionResults

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Sì
forceRecalculate	bool	No

Risposta

Restituisce: BulkAggregateQuestionResultsResponse

Esempio

bulkAggregateQuestionResults Esempio

Copy

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

combineCommentsWithQuestionResults

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const CombineCommentsWithQuestionResultsOptions&	Sì

Risposta

Restituisce: CombineQuestionResultsWithCommentsResponse

Esempio

Esempio combineCommentsWithQuestionResults

Copy

utility::string_t tenantId = utility::string_t("my-tenant-123");
CombineCommentsWithQuestionResultsOptions options;
options.questionId = utility::string_t("question-789");
options.maxComments = boost::optional<int>(50);
api->combineCommentsWithQuestionResults(tenantId, options).then(
    [](pplx::task<std::shared_ptr<CombineQuestionResultsWithCommentsResponse>> task){
        try{
            auto respPtr = task.get();
            auto combined = std::make_shared<CombineQuestionResultsWithCommentsResponse>(*respPtr);
            // Usa combined come necessario
        }catch(const std::exception&){
        }
    });

addSSOUser

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
createAPISSOUserData	CreateAPISSOUserData	Sì

Risposta

Restituisce: AddSSOUserAPIResponse

Esempio

Esempio addSSOUser

Copy

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

deleteSSOUser

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
options	const DeleteSSOUserOptions&	Sì

Risposta

Restituisce: DeleteSSOUserAPIResponse

Esempio

deleteSSOUser Esempio

Copy

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

getSSOUserByEmail

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
email	string	Sì

Risposta

Restituisce: GetSSOUserByEmailAPIResponse

Esempio

Esempio getSSOUserByEmail

Copy

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

getSSOUserById

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
id	string	Sì

Risposta

Restituisce: GetSSOUserByIdAPIResponse

Esempio

Esempio getSSOUserById

Copy

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

getSSOUsers

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
skip	int32_t	No

Risposta

Restituisce: GetSSOUsersResponse

Esempio

Esempio getSSOUsers

Copy

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

patchSSOUser

Parameters

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
updateAPISSOUserData	UpdateAPISSOUserData	Sì
updateComments	bool	No

Response

Restituisce: PatchSSOUserAPIResponse

Example

patchSSOUser Esempio

Copy

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

putSSOUser

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
updateAPISSOUserData	UpdateAPISSOUserData	Sì
updateComments	bool	No

Risposta

Returns: PutSSOUserAPIResponse

Esempio

Esempio putSSOUser

Copy

UpdateAPISSOUserData userData;
userData.email = utility::conversions::to_string_t("alice@example.com");
userData.first_name = utility::conversions::to_string_t("Alice");
userData.last_name = utility::conversions::to_string_t("Smith");
userData.role = utility::conversions::to_string_t("moderator");
api->putSSOUser(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("alice.smith"),
    userData,
    boost::optional<bool>(true)
).then([](pplx::task<std::shared_ptr<PutSSOUserAPIResponse>> t) {
    auto response = t.get();
});

createSubscription

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Sì

Risposta

Restituisce: CreateSubscriptionAPIResponse

Esempio

Esempio createSubscription

Copy

auto tenantId = U("my-tenant-123");
CreateAPIUserSubscriptionData subscriptionData;
subscriptionData.email = U("user@example.com");
subscriptionData.planId = U("premium-plan");
subscriptionData.couponCode = boost::optional<utility::string_t>(U("WELCOME10"));
api->createSubscription(tenantId, subscriptionData)
    .then([](pplx::task<std::shared_ptr<CreateSubscriptionAPIResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception&) {
        }
    });

deleteSubscription

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
userId	string	No

Risposta

Restituisce: DeleteSubscriptionAPIResponse

Esempio

Esempio di deleteSubscription

Copy

api->deleteSubscription(utility::string_t(U("my-tenant-123")), utility::string_t(U("sub-456")), boost::optional<utility::string_t>(utility::string_t(U("user@example.com"))))
    .then([](std::shared_ptr<DeleteSubscriptionAPIResponse> resp){
        if (resp) {
        }
    });

getSubscriptions

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
userId	string	No

Risposta

Restituisce: GetSubscriptionsAPIResponse

Esempio

Esempio getSubscriptions

Copy

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

updateSubscription

Parametri

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	Yes
userId	string	No

Risposta

Restituisce: UpdateSubscriptionAPIResponse

Esempio

Esempio di updateSubscription

Copy

UpdateAPIUserSubscriptionData subscriptionData;
subscriptionData.plan = utility::conversions::to_string_t("premium");
subscriptionData.active = true;
api->updateSubscription(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("sub-987654"),
    subscriptionData,
    boost::optional<utility::string_t>(utility::conversions::to_string_t("admin-user-456"))
).then([](std::shared_ptr<UpdateSubscriptionAPIResponse> response){
    bool ok = response && response->isSuccess;
    (void)ok;
});

getTenantDailyUsages

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetTenantDailyUsagesOptions&	Sì

Risposta

Restituisce: GetTenantDailyUsagesResponse

Esempio

getTenantDailyUsages Esempio

Copy

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

createTenantPackage

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
createTenantPackageBody	CreateTenantPackageBody	Sì

Risposta

Restituisce: CreateTenantPackageResponse

Esempio

Esempio createTenantPackage

Copy

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

deleteTenantPackage

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
id	string	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di deleteTenantPackage

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto packageId = utility::conversions::to_string_t("pkg-456");
boost::optional<utility::string_t> optTenant = tenantId;
boost::optional<utility::string_t> optPackage = packageId;
api->deleteTenantPackage(optTenant.value(), optPackage.value())
    .then([](std::shared_ptr<APIEmptyResponse>){ })
    .then([](pplx::task<void> t){ try{ t.get(); }catch(const std::exception&){ } });

getTenantPackage

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
id	string	Yes

Risposta

Restituisce: GetTenantPackageResponse

Esempio

Esempio getTenantPackage

Copy

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

getTenantPackages

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
skip	double	No

Risposta

Restituisce: GetTenantPackagesResponse

Esempio

Esempio getTenantPackages

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
boost::optional<double> skip = 20.0;
api->getTenantPackages(tenantId, skip)
    .then([](std::shared_ptr<GetTenantPackagesResponse> resp) {
        (void)resp;
    });

replaceTenantPackage

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
replaceTenantPackageBody	ReplaceTenantPackageBody	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

replaceTenantPackage Esempio

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto pkgId = utility::conversions::to_string_t("pkg-456");
ReplaceTenantPackageBody body;
body.planId = utility::conversions::to_string_t("enterprise");
body.notes = boost::optional<utility::string_t>(utility::conversions::to_string_t("Upgrade request"));
api->replaceTenantPackage(tenantId, pkgId, body)
    .then([](std::shared_ptr<APIEmptyResponse>) { })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) { }
    });

updateTenantPackage

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
id	string	Yes
updateTenantPackageBody	UpdateTenantPackageBody	Yes

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio updateTenantPackage

Copy

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

createTenantUser

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
createTenantUserBody	CreateTenantUserBody	Sì

Risposta

Restituisce: CreateTenantUserResponse

Esempio

Esempio createTenantUser

Copy

auto body = CreateTenantUserBody{};
body.email = utility::conversions::to_string_t("newuser@example.com");
body.firstName = utility::conversions::to_string_t("Alice");
body.lastName = utility::conversions::to_string_t("Smith");
body.role = boost::optional<utility::string_t>(utility::conversions::to_string_t("moderator"));
api->createTenantUser(utility::conversions::to_string_t("my-tenant-123"), body)
    .then([](pplx::task<std::shared_ptr<CreateTenantUserResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception&) {
        }
    });

deleteTenantUser

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
options	const DeleteTenantUserOptions&	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio deleteTenantUser

Copy

DeleteTenantUserOptions options;
options.reason = boost::optional<utility::string_t>(U("User requested deletion"));
api->deleteTenantUser(U("my-tenant-123"), U("user@example.com"), options)
    .then([](std::shared_ptr<APIEmptyResponse> resp){
        (void)resp;
    });

getTenantUser

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
id	string	Sì

Risposta

Restituisce: GetTenantUserResponse

Esempio

Esempio getTenantUser

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user@example.com");
api->getTenantUser(tenantId, userId)
    .then([](pplx::task<std::shared_ptr<GetTenantUserResponse>> task) {
        try {
            auto response = task.get();
            // Usa la risposta come necessario
        } catch (const std::exception&) {
            // Gestione degli errori
        }
    });

getTenantUsers

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
skip	double	No

Risposta

Restituisce: GetTenantUsersResponse

Esempio

Esempio getTenantUsers

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<double> skip = 10;
api->getTenantUsers(tenantId, skip).then([](pplx::task<std::shared_ptr<GetTenantUsersResponse>> t){
    try {
        auto resp = t.get();
    } catch (const std::exception&) {
    }
});

replaceTenantUser

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
replaceTenantUserBody	ReplaceTenantUserBody	Sì
updateComments	string	No

Risposta

Restituisce: APIEmptyResponse

Esempio

replaceTenantUser Esempio

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto userId = utility::string_t(U("john.doe@example.com"));
ReplaceTenantUserBody replaceBody;
replaceBody.email = utility::string_t(U("john.doe@example.com"));
replaceBody.role = utility::string_t(U("admin"));
boost::optional<utility::string_t> updateComments = utility::string_t(U("Promoted to admin"));
api->replaceTenantUser(tenantId, userId, replaceBody, updateComments)
    .then([](std::shared_ptr<APIEmptyResponse> resp){ });

sendLoginLink

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
id	string	Yes
redirectURL	string	No

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio sendLoginLink

Copy

api->sendLoginLink(
    U("my-tenant-123"),
    U("user@example.com"),
    boost::make_optional(U("https://myapp.com/auth/callback"))
).then([](std::shared_ptr<APIEmptyResponse> resp) {
});

updateTenantUser

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
updateTenantUserBody	UpdateTenantUserBody	Sì
updateComments	string	No

Risposta

Restituisce: APIEmptyResponse

Esempio

updateTenantUser Esempio

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user-456");
UpdateTenantUserBody body;
body.email = U("john.doe@example.com");
body.role = U("admin");
boost::optional<utility::string_t> updateComments = U("Promoted to admin");
api->updateTenantUser(tenantId, userId, body, updateComments)
    .then([](std::shared_ptr<APIEmptyResponse>){ });

createTenant

Parameters

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
createTenantBody	CreateTenantBody	Sì

Response

Restituisce: CreateTenantResponse

Example

Esempio createTenant

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
CreateTenantBody body;
body.setName(utility::conversions::to_string_t("Acme Corp"));
body.setAdminEmail(utility::conversions::to_string_t("admin@acme.com"));
body.setPlan(utility::conversions::to_string_t("enterprise"));
body.setDescription(boost::optional<utility::string_t>(utility::conversions::to_string_t("Primary tenant for Acme")));
api->createTenant(tenantId, body).then([](pplx::task<std::shared_ptr<CreateTenantResponse>> t){
    auto resp = t.get();
});

deleteTenant

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
id	string	Yes
sure	string	No

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio deleteTenant

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user@example.com");
boost::optional<utility::string_t> sure = utility::conversions::to_string_t("true");
api->deleteTenant(tenantId, userId, sure)
   .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> t){
       try{
           auto resp = t.get();
           auto result = std::make_shared<APIEmptyResponse>(*resp);
       }catch(const std::exception&){})

getTenant

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
id	string	Sì

Risposta

Restituisce: GetTenantResponse

Esempio

Esempio getTenant

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto id = utility::conversions::to_string_t("tenant-admin-456");
boost::optional<utility::string_t> includeDetails = utility::conversions::to_string_t("full");
api->getTenant(tenantId, id)
    .then([](std::shared_ptr<GetTenantResponse> resp) {
        if (resp) {
            std::wcout << resp->toString() << std::endl;
        }
    });

getTenants

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetTenantsOptions&	Sì

Risposta

Restituisce: GetTenantsResponse

Esempio

Esempio getTenants

Copy

GetTenantsOptions options;
options.includeDeleted = boost::make_optional(false);
options.searchTerm = boost::make_optional(utility::string_t(U("enterprise")));
api->getTenants(utility::string_t(U("my-tenant-123")), options)
    .then([](std::shared_ptr<GetTenantsResponse> response) {
    })
    .then([](pplx::task<void> t){ try{ t.get(); }catch(...){} });

updateTenant

Parametri

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateTenantBody	UpdateTenantBody	Yes

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio updateTenant

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto recordId = utility::string_t(U("tenant-456"));
UpdateTenantBody body;
body.name = boost::optional<utility::string_t>(U("Acme Corp"));
body.contactEmail = boost::optional<utility::string_t>(U("admin@acme.com"));
api->updateTenant(tenantId, recordId, body).then([](std::shared_ptr<APIEmptyResponse> resp) {
    auto log = std::make_shared<utility::string_t>(U("Tenant update succeeded"));
    (void)resp;
    (void)log;
});

changeTicketState

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
userId	string	Yes
id	string	Yes
changeTicketStateBody	ChangeTicketStateBody	Yes

Risposta

Restituisce: ChangeTicketStateResponse

Esempio

Esempio di changeTicketState

Copy

auto body = std::make_shared<ChangeTicketStateBody>();
body->state = U("closed");
body->comment = boost::optional<utility::string_t>(U("Ticket resolved"));
api->changeTicketState(U("my-tenant-123"), U("user@example.com"), U("ticket-456"), *body)
    .then([](std::shared_ptr<ChangeTicketStateResponse>) {});

createTicket

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
userId	string	Sì
createTicketBody	CreateTicketBody	Sì

Risposta

Restituisce: CreateTicketResponse

Esempio

Esempio createTicket

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("john.doe@example.com");
CreateTicketBody ticketBody;
ticketBody.setSubject(utility::conversions::to_string_t("Login Issue"));
ticketBody.setDescription(utility::conversions::to_string_t("Cannot log in after password reset."));
boost::optional<int> priority = 2;
ticketBody.setPriority(priority);
api->createTicket(tenantId, userId, ticketBody).then([](pplx::task<std::shared_ptr<CreateTicketResponse>> task){
    try{
        auto response = task.get();
        // Usa la risposta secondo necessità
    }catch(const std::exception&){
        // Gestisci l'errore
    }
});

getTicket

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
userId	string	No

Risposta

Restituisce: GetTicketResponse

Esempio

Esempio getTicket

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t ticketId = U("ticket-789");
boost::optional<utility::string_t> userId = U("alice@example.com");
api->getTicket(tenantId, ticketId, userId).then([](pplx::task<std::shared_ptr<GetTicketResponse>> task){
    try{
        auto resp = task.get();
    }catch(const std::exception&){
    }
});

getTickets

Parametri

Nome	Tipo	Richiesto	Descrizione
tenantId	string	Yes
options	const GetTicketsOptions&	Yes

Risposta

Restituisce: GetTicketsResponse

Esempio

Esempio getTickets

Copy

auto options = GetTicketsOptions{};
options.page = boost::optional<int>(1);
options.status = boost::optional<utility::string_t>(U("open"));
api->getTickets(U("my-tenant-123"), options).then([](pplx::task<std::shared_ptr<GetTicketsResponse>> task) {
    try {
        auto response = task.get();
        auto responseCopy = std::make_shared<GetTicketsResponse>(*response);
    } catch (const std::exception&) {
    }
});

getTranslations

Parametri

Nome	Tipo	Obbligatorio
r_namespace	string	Sì
component	string	Sì
options	const GetTranslationsOptions&	Sì

Risposta

Restituisce: GetTranslationsResponse

Esempio

Esempio getTranslations

Copy

utility::string_t ns = U("my-tenant-123");
utility::string_t comp = U("comments");
auto optsPtr = std::make_shared<GetTranslationsOptions>();
optsPtr->language = boost::make_optional(U("en"));
optsPtr->fallback = boost::none;
api->getTranslations(ns, comp, *optsPtr)
    .then([](pplx::task<std::shared_ptr<GetTranslationsResponse>> t) {
        try {
            auto resp = t.get();
        } catch (const std::exception& e) {
        }
    });

uploadImage

Upload and resize an image

Parameters

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

Response

Restituisce: UploadImageResponse

Example

Esempio uploadImage

Copy

auto fileStream = concurrency::streams::fstream::open_istream(U("avatar.png"), std::ios::in).get();
HttpContent file(fileStream, U("image/png"));
UploadImageOptions options;
options.description = boost::optional<utility::string_t>(U("Profile picture"));
options.width = boost::optional<int>(256);
options.height = boost::optional<int>(256);
api->uploadImage(U("my-tenant-123"), file, options).then([](pplx::task<std::shared_ptr<UploadImageResponse>> t){
    auto resp = t.get();
});

getUserBadgeProgressById

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
id	string	Sì

Risposta

Restituisce: APIGetUserBadgeProgressResponse

Esempio

Esempio getUserBadgeProgressById

Copy

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

getUserBadgeProgressByUserId

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
userId	string	Sì

Risposta

Restituisce: APIGetUserBadgeProgressResponse

Esempio

getUserBadgeProgressByUserId Esempio

Copy

boost::optional<std::shared_ptr<APIGetUserBadgeProgressResponse>> responseOpt;
api->getUserBadgeProgressByUserId(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("user@example.com"))
    .then([&responseOpt](pplx::task<std::shared_ptr<APIGetUserBadgeProgressResponse>> t) {
        try {
            responseOpt = t.get();
        } catch (...) {
            responseOpt = boost::none;
        }
    });

getUserBadgeProgressList

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetUserBadgeProgressListOptions&	Sì

Risposta

Restituisce: APIGetUserBadgeProgressListResponse

Esempio

Esempio getUserBadgeProgressList

Copy

utility::string_t tenantId = U("my-tenant-123");
GetUserBadgeProgressListOptions options;
options.userId = U("user@example.com");
options.page = boost::optional<int>(1);
options.pageSize = boost::optional<int>(20);
api->getUserBadgeProgressList(tenantId, options)
    .then([](std::shared_ptr<APIGetUserBadgeProgressListResponse> resp) {
        if (!resp) return;
        for (const auto& badge : resp->badges) {
            // elabora il badge
        }
    });

createUserBadge

Parametri

Name	Type	Required	Description
tenantId	string	Sì
createUserBadgeParams	CreateUserBadgeParams	Sì

Risposta

Restituisce: APICreateUserBadgeResponse

Esempio

Esempio createUserBadge

Copy

auto tenantId = U("my-tenant-123");
CreateUserBadgeParams badgeParams;
badgeParams.userEmail = U("user@example.com");
badgeParams.badgeCode = U("gold");
badgeParams.expirationDate = boost::optional<utility::datetime>(utility::datetime::utc_now() + utility::datetime::from_seconds(2592000));
api->createUserBadge(tenantId, badgeParams).then([](std::shared_ptr<APICreateUserBadgeResponse> resp){
    if (resp && resp->success) {
        auto result = std::make_shared<APICreateUserBadgeResponse>(*resp);
    }
});

deleteUserBadge

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
id	string	Sì

Risposta

Restituisce: APIEmptySuccessResponse

Esempio

Esempio deleteUserBadge

Copy

auto tenantId = boost::optional<utility::string_t>(U("my-tenant-123"));
auto badgeId = utility::string_t(U("badge-789"));
api->deleteUserBadge(tenantId.value(), badgeId)
    .then([](std::shared_ptr<APIEmptySuccessResponse> resp){
        auto copy = std::make_shared<APIEmptySuccessResponse>(*resp);
    })
    .then([](pplx::task<void> t){
        try{ t.get(); } catch(const std::exception&){ }
    });

getUserBadge

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
id	string	Sì

Risposta

Restituisce: APIGetUserBadgeResponse

Esempio

Esempio getUserBadge

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user-456");
api->getUserBadge(tenantId, userId).then([](pplx::task<std::shared_ptr<APIGetUserBadgeResponse>> t){
    try{
        auto resp = t.get();
        boost::optional<std::string> badgeUrl = resp->badge_url ? boost::optional<std::string>(*resp->badge_url) : boost::none;
    }catch(const std::exception&){
    }
});

getUserBadges

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetUserBadgesOptions&	Sì

Risposta

Restituisce: APIGetUserBadgesResponse

Esempio

Esempio getUserBadges

Copy

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

updateUserBadge

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
updateUserBadgeParams	UpdateUserBadgeParams	Sì

Risposta

Restituisce: APIEmptySuccessResponse

Esempio

Esempio updateUserBadge

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user@example.com");
UpdateUserBadgeParams params;
params.badgeId = utility::conversions::to_string_t("vip-badge");
params.expiration = boost::optional<utility::datetime>(utility::datetime::from_string(U("2024-12-31T23:59:59Z")));
api->updateUserBadge(tenantId, userId, params)
    .then([](std::shared_ptr<APIEmptySuccessResponse> resp){
        std::cout << "Badge updated successfully\n";
    })
    .catch([](std::exception const& e){
        std::cerr << "Error updating badge: " << e.what() << "\n";
    });

getUserNotificationCount

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
sso	string	No

Risposta

Restituisce: GetUserNotificationCountResponse

Esempio

Esempio getUserNotificationCount

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("user@example.com");
api->getUserNotificationCount(tenantId, sso).then([](pplx::task<std::shared_ptr<GetUserNotificationCountResponse>> t){
    try{
        auto resp = t.get();
        // usa resp secondo necessità
    }catch(const std::exception&){
        // gestisci l'errore
    }
});

getUserNotifications

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const GetUserNotificationsOptions&	Sì

Risposta

Restituisce: GetMyNotificationsResponse

Esempio

getUserNotifications Esempio

Copy

utility::string_t tenantId = utility::string_t("my-tenant-123");
GetUserNotificationsOptions options;
options.limit = boost::optional<int>(20);
options.unreadOnly = boost::optional<bool>(true);
api->getUserNotifications(tenantId, options)
    .then([](pplx::task<std::shared_ptr<GetMyNotificationsResponse>> task){
        auto resp = task.get();
        auto notifications = std::make_shared<GetMyNotificationsResponse>(*resp);
    });

resetUserNotificationCount

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
sso	string	No

Risposta

Restituisce: ResetUserNotificationsResponse

Esempio

resetUserNotificationCount Esempio

Copy

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

resetUserNotifications

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
options	const ResetUserNotificationsOptions&	Sì

Risposta

Restituisce: ResetUserNotificationsResponse

Esempio

resetUserNotifications Esempio

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
ResetUserNotificationsOptions options;
options.email = boost::optional<utility::string_t>(U("user@example.com"));
api->resetUserNotifications(tenantId, options)
    .then([](std::shared_ptr<ResetUserNotificationsResponse> resp) {
        // Process response
    });

updateUserNotificationCommentSubscriptionStatus

Abilita o disabilita le notifiche per un commento specifico.

Parametri

Nome	Tipo	Richiesto
tenantId	string	Yes
notificationId	string	Yes
optedInOrOut	string	Yes
commentId	string	Yes
sso	string	No

Risposta

Restituisce: UpdateUserNotificationCommentSubscriptionStatusResponse

Esempio

Esempio di updateUserNotificationCommentSubscriptionStatus

Copy

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

updateUserNotificationPageSubscriptionStatus

Abilita o disabilita le notifiche per una pagina. Quando gli utenti sono iscritti a una pagina, le notifiche vengono create per i nuovi commenti radice, e anche

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
url	string	Yes
pageTitle	string	Yes
subscribedOrUnsubscribed	string	Yes
sso	string	No

Response

Restituisce: UpdateUserNotificationPageSubscriptionStatusResponse

Example

Esempio di updateUserNotificationPageSubscriptionStatus

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("page-456");
utility::string_t url = U("https://example.com/articles/awesome-article");
utility::string_t pageTitle = U("Awesome Article");
utility::string_t subscription = U("subscribed");
boost::optional<utility::string_t> sso = boost::make_optional<utility::string_t>(U("sso-token-789"));
api->updateUserNotificationPageSubscriptionStatus(tenantId, urlId, url, pageTitle, subscription, sso)
    .then([](std::shared_ptr<UpdateUserNotificationPageSubscriptionStatusResponse> resp) {
        // elabora la risposta se necessario
    });

updateUserNotificationStatus

Parametri

Name	Type	Required
tenantId	string	Yes
notificationId	string	Yes
newStatus	string	Yes
sso	string	No

Risposta

Restituisce: UpdateUserNotificationStatusResponse

Esempio

Esempio di updateUserNotificationStatus

Copy

api->updateUserNotificationStatus(
    U("my-tenant-123"),
    U("notif-456"),
    U("read"),
    boost::optional<utility::string_t>(U("sso-token-abc"))
).then([](std::shared_ptr<UpdateUserNotificationStatusResponse> resp) {
}).wait();

getUserPresenceStatuses

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
urlIdWS	string	Yes
userIds	string	Yes

Risposta

Restituisce: GetUserPresenceStatusesResponse

Esempio

Esempio getUserPresenceStatuses

Copy

auto tenantId = U("my-tenant-123");
auto urlIdWS = U("article-789");
auto userIds = U("alice@example.com,bob@example.com");
boost::optional<utility::string_t> optionalFilter = boost::none;
api->getUserPresenceStatuses(tenantId, urlIdWS, userIds)
    .then([](pplx::task<std::shared_ptr<GetUserPresenceStatusesResponse>> t){
        try{
            auto response = t.get();
        }catch(...){
        }
    });

searchUsers

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Yes
urlId	string	Yes
options	const SearchUsersOptions&	Yes

Risposta

Restituisce: SearchUsersResult

Esempio

Esempio searchUsers

Copy

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

getUser

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Yes
id	string	Yes

Risposta

Restituisce: GetUserResponse

Esempio

Esempio getUser

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user-789");
boost::optional<utility::string_t> optTag = boost::none;
api->getUser(tenantId, userId)
    .then([=](pplx::task<std::shared_ptr<GetUserResponse>> task) {
        try {
            auto response = task.get();
            if (!response) {
                response = std::make_shared<GetUserResponse>();
            }
            // elabora la risposta secondo necessità
        } catch (const std::exception&) {
            // gestisci l'errore
        }
    });

createVote

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
commentId	string	Sì
direction	string	Sì
options	const CreateVoteOptions&	Sì

Risposta

Restituisce: VoteResponse

Esempio

Esempio createVote

Copy

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

deleteVote

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
id	string	Sì
editKey	string	No

Risposta

Restituisce: VoteDeleteResponse

Esempio

Esempio deleteVote

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto voteId = utility::conversions::to_string_t("vote-9876");
boost::optional<utility::string_t> editKey = utility::conversions::to_string_t("edit-abc123");
api->deleteVote(tenantId, voteId, editKey).then([](pplx::task<std::shared_ptr<VoteDeleteResponse>> task) {
    try {
        auto response = task.get();
        // Elabora la risposta secondo necessità
    } catch (const std::exception&) {
        // Gestisci l'errore
    }
});

getVotes

Parametri

Nome	Tipo	Obbligatorio	Descrizione
tenantId	string	Sì
urlId	string	Sì

Risposta

Restituisce: GetVotesResponse

Esempio

Esempio getVotes

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto urlId = utility::string_t(U("article-456"));
boost::optional<utility::string_t> extraHeader = boost::none;
api->getVotes(tenantId, urlId).then([=](pplx::task<std::shared_ptr<GetVotesResponse>> task) {
    try {
        auto original = task.get();
        auto response = std::make_shared<GetVotesResponse>(*original);
    } catch (...) {
        // gestione dell'errore
    }
});

getVotesForUser

Parametri

Nome	Tipo	Obbligatorio
tenantId	string	Sì
urlId	string	Sì
options	const GetVotesForUserOptions&	Sì

Risposta

Restituisce: GetVotesForUserResponse

Esempio

Esempio getVotesForUser

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto urlId = utility::string_t(U("post-456"));
GetVotesForUserOptions options;
options.page = boost::optional<int>(2);
options.pageSize = boost::optional<int>(50);
api->getVotesForUser(tenantId, urlId, options).then([](std::shared_ptr<GetVotesForUserResponse> response) {
    if (response) {
        // gestire la risposta, ad esempio, iterare i voti
    }
});

Hai bisogno di aiuto?

Se riscontri problemi o hai domande sul SDK C++, per favore:

Contribuire

I contributi sono benvenuti! Visita il repository GitHub per le linee guida sui contributi.

Lingua 🇮🇹 Italiano

Documentazione

Primi passi

Riferimento API

Utilizzo

Aggregazione

Log di audit

Autenticazione

Blocca dal commento

Verifica commenti bloccati

Commenti

Commenti per utente

Configurazioni dominio

Modelli email

Log eventi

Post del feed

Segnala commento

GIF

Hashtag

Moderazione

Moderatori

Conteggio notifiche

Notifiche

Reazioni pagina

Pagine

Eventi webhook in sospeso

Configurazioni domande

Risultati domande

Aggregazione risultati domande

Utenti SSO

Abbonamenti

Utilizzo giornaliero tenant

Pacchetti tenant

Utenti tenant

Tenant

Ticket

Traduzioni

Carica immagine

Progresso badge utente

Badge utente

Notifiche utente

Stato presenza utente

Ricerca utenti

Utenti

Voti

FastComments SDK C++

Repository

Requisiti

Installazione

Installa dipendenze

Compilare dal sorgente

Installazione

Contenuto della libreria

API pubbliche vs sicure

Avvio rapido

Utilizzo delle API Autenticate (DefaultAPI)

Utilizzo delle API Pubbliche (PublicAPI)

Utilizzo delle API di Moderazione (ModerationApi)

Problemi comuni

Eseguire chiamate API: sincrone vs asincrone

Chiamate sincrone con .get()

Chiamate asincrone con .then()

Scegliere tra sincrono e asincrono

Note

ID di broadcast

SSO (Accesso unico)

Utilizzo SSO

SSO semplice

SSO sicuro

Documentazione per fastcomments

Documentazione per gli endpoint API

aggregate

Parametri

Risposta

Esempio

getAuditLogs

Parametri

Risposta

Esempio

logoutPublic

Chiamate sincrone con `.get()`

Chiamate asincrone con `.then()`