SDK C++ de FastComments

Ceci est le SDK C++ officiel pour FastComments.

SDK C++ officiel pour l'API FastComments

Dépôt

Prérequis

C++17 ou version ultérieure
CMake 3.14 ou version ultérieure
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (téléchargé automatiquement pour les tests)

Installation

Installer les dépendances

sudo apt install libcpprest-dev libboost-all-dev

Compiler à partir du code source

mkdir build
cd build
cmake ..
make

Installation

sudo make install

Contenu de la bibliothèque

Cette bibliothèque contient le client API généré et les utilitaires SSO pour faciliter le travail avec l’API.

API Client Library Docs

API publiques vs sécurisées

Pour le client API, il existe trois classes, DefaultApi, PublicApi et ModerationApi. Le DefaultApi contient des méthodes qui nécessitent votre clé API, et le PublicApi contient
des méthodes qui peuvent être appelées directement depuis un navigateur/appareil mobile/etc. sans authentification. Le ModerationApi fournit une suite étendue d’API de modération en direct et rapides. Chaque méthode du ModerationApi accepte un paramètre sso et peut s’authentifier via SSO ou un cookie de session FastComments.com.

Démarrage rapide

Utilisation des API authentifiées (DefaultAPI)

Important :

Vous devez définir l’URL de base (le générateur cpp‑restsdk ne la lit pas depuis la spécification OpenAPI)
Vous devez définir votre clé API sur l'ApiClient avant d’effectuer des requêtes authentifiées. Sinon, les requêtes échoueront avec une erreur 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;
}

Utilisation des API publiques (PublicAPI)

Les points de terminaison publics ne nécessitent pas d’authentification :

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

Utilisation des API de modération (ModerationApi)

L'ModerationApi alimente le tableau de bord du modérateur. Chaque méthode accepte un paramètre sso afin que l’appel s’exécute au nom d’un modérateur authentifié via SSO (voir la section SSO ci‑dessous pour savoir comment créer un jeton) :

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

Problèmes courants

Erreur « URI must contain a hostname » : Assurez‑vous d’appeler config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) avant de créer l'ApiClient. Le générateur cpp‑restsdk ne lit pas automatiquement l’URL du serveur depuis la spécification OpenAPI.
Erreur 401 « missing‑api‑key » : Assurez‑vous d’appeler config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) avant de créer l’instance DefaultAPI.
Classe API incorrecte : Utilisez DefaultApi pour les requêtes authentifiées côté serveur, PublicApi pour les requêtes côté client/public, et ModerationApi pour les requêtes du tableau de bord du modérateur (authentifiées avec un jeton SSO de modérateur).

Appels d'API : synchrones vs asynchrones

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

Appels synchrones avec `.get()`

Utilisez .get() pour bloquer le thread appelant jusqu'à ce que la requête soit terminée et récupérer le résultat de façon synchrone :

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

Appels asynchrones avec `.then()`

Utilisez .then() pour une exécution asynchrone sans blocage avec des rappels :

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;

Choisir entre synchrone et asynchrone

Le choix dépend de votre environnement d'exécution et de l'architecture de votre application :

.get() (blocage synchrone)

Bloque le thread appelant jusqu'à ce que la requête HTTP soit terminée
Flux de code plus simple, plus facile à comprendre
Convient aux threads de travail dédiés, au traitement par lots ou aux outils en ligne de commande
Pas approprié pour les boucles d'événements, les threads d'interface graphique ou les serveurs monothreads

.then() (asynchrone sans blocage)

Retourne immédiatement, le rappel s'exécute lorsque la requête est terminée
Ne bloque pas le thread appelant
Nécessaire pour les architectures réactives, les applications graphiques ou les boucles d'événements monothreads
Permet de chaîner plusieurs opérations
Flux de contrôle plus complexe

La suite de tests du SDK utilise exclusivement .get(), mais cela convient à l'environnement de test où le blocage est acceptable.

Remarques

Identifiants de diffusion

Vous verrez qu'il faut transmettre un broadcastId dans certaines appels d'API. Lorsque vous recevez des événements, vous récupérerez cet ID, ce qui vous permet d'ignorer l'événement si vous comptez appliquer des modifications de façon optimiste côté client (ce que vous voudrez probablement faire, car cela offre la meilleure expérience). Transmettez un UUID ici. L'ID doit être suffisamment unique pour ne pas apparaître deux fois au cours d'une session de navigateur.

SSO (Authentification unique)

Pour des exemples d'authentification unique, voir ci‑dessous.

Utilisation du SSO

SSO simple

#include <fastcomments/sso/fastcomments_sso.hpp>
#include <iostream>

using namespace fastcomments::sso;

int main() {
    SimpleSSOUserData user("user-123", "user@example.com", "https://example.com/avatar.jpg");
    FastCommentsSSO sso = FastCommentsSSO::newSimple(user);
    std::string token = sso.createToken();

    std::cout << "SSO Token: " << token << std::endl;
    return 0;
}

SSO sécurisé

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

Documentation pour FastComments

Documentation des points de terminaison d'API

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

Classe	Méthode	Requête HTTP	Description
DefaultApi	addDomainConfig	POST /api/v1/domain-configs
DefaultApi	addHashTag	POST /api/v1/hash-tags
DefaultApi	addHashTagsBulk	POST /api/v1/hash-tags/bulk
DefaultApi	addPage	POST /api/v1/pages
DefaultApi	addSSOUser	POST /api/v1/sso-users
DefaultApi	aggregate	POST /api/v1/aggregate	Agrège des documents en les regroupant (si groupBy est fourni) et en appliquant plusieurs opérations. Différentes opérations (par ex. sum, countDistinct, avg, etc.) sont prises en charge.
DefaultApi	aggregateQuestionResults	GET /api/v1/question-results-aggregation
DefaultApi	blockUserFromComment	POST /api/v1/comments/{id}/block
DefaultApi	bulkAggregateQuestionResults	POST /api/v1/question-results-aggregation/bulk
DefaultApi	changeTicketState	PATCH /api/v1/tickets/{id}/state
DefaultApi	combineCommentsWithQuestionResults	GET /api/v1/question-results-aggregation/combine/comments
DefaultApi	createEmailTemplate	POST /api/v1/email-templates
DefaultApi	createFeedPost	POST /api/v1/feed-posts
DefaultApi	createModerator	POST /api/v1/moderators
DefaultApi	createQuestionConfig	POST /api/v1/question-configs
DefaultApi	createQuestionResult	POST /api/v1/question-results
DefaultApi	createSubscription	POST /api/v1/subscriptions
DefaultApi	createTenant	POST /api/v1/tenants
DefaultApi	createTenantPackage	POST /api/v1/tenant-packages
DefaultApi	createTenantUser	POST /api/v1/tenant-users
DefaultApi	createTicket	POST /api/v1/tickets
DefaultApi	createUserBadge	POST /api/v1/user-badges
DefaultApi	createVote	POST /api/v1/votes
DefaultApi	deleteComment	DELETE /api/v1/comments/{id}
DefaultApi	deleteDomainConfig	DELETE /api/v1/domain-configs/{domain}
DefaultApi	deleteEmailTemplate	DELETE /api/v1/email-templates/{id}
DefaultApi	deleteEmailTemplateRenderError	DELETE /api/v1/email-templates/{id}/render-errors/{errorId}
DefaultApi	deleteHashTag	DELETE /api/v1/hash-tags/{tag}
DefaultApi	deleteModerator	DELETE /api/v1/moderators/{id}
DefaultApi	deleteNotificationCount	DELETE /api/v1/notification-count/{id}
DefaultApi	deletePage	DELETE /api/v1/pages/{id}
DefaultApi	deletePendingWebhookEvent	DELETE /api/v1/pending-webhook-events/{id}
DefaultApi	deleteQuestionConfig	DELETE /api/v1/question-configs/{id}
DefaultApi	deleteQuestionResult	DELETE /api/v1/question-results/{id}
DefaultApi	deleteSSOUser	DELETE /api/v1/sso-users/{id}
DefaultApi	deleteSubscription	DELETE /api/v1/subscriptions/{id}
DefaultApi	deleteTenant	DELETE /api/v1/tenants/{id}
DefaultApi	deleteTenantPackage	DELETE /api/v1/tenant-packages/{id}
DefaultApi	deleteTenantUser	DELETE /api/v1/tenant-users/{id}
DefaultApi	deleteUserBadge	DELETE /api/v1/user-badges/{id}
DefaultApi	deleteVote	DELETE /api/v1/votes/{id}
DefaultApi	flagComment	POST /api/v1/comments/{id}/flag
DefaultApi	getAuditLogs	GET /api/v1/audit-logs
DefaultApi	getCachedNotificationCount	GET /api/v1/notification-count/{id}
DefaultApi	getComment	GET /api/v1/comments/{id}
DefaultApi	getComments	GET /api/v1/comments
DefaultApi	getDomainConfig	GET /api/v1/domain-configs/{domain}
DefaultApi	getDomainConfigs	GET /api/v1/domain-configs
DefaultApi	getEmailTemplate	GET /api/v1/email-templates/{id}
DefaultApi	getEmailTemplateDefinitions	GET /api/v1/email-templates/definitions
DefaultApi	getEmailTemplateRenderErrors	GET /api/v1/email-templates/{id}/render-errors
DefaultApi	getEmailTemplates	GET /api/v1/email-templates
DefaultApi	getFeedPosts	GET /api/v1/feed-posts	req tenantId afterId
DefaultApi	getHashTags	GET /api/v1/hash-tags
DefaultApi	getModerator	GET /api/v1/moderators/{id}
DefaultApi	getModerators	GET /api/v1/moderators
DefaultApi	getNotificationCount	GET /api/v1/notifications/count
DefaultApi	getNotifications	GET /api/v1/notifications
DefaultApi	getPageByURLId	GET /api/v1/pages/by-url-id
DefaultApi	getPages	GET /api/v1/pages
DefaultApi	getPendingWebhookEventCount	GET /api/v1/pending-webhook-events/count
DefaultApi	getPendingWebhookEvents	GET /api/v1/pending-webhook-events
DefaultApi	getQuestionConfig	GET /api/v1/question-configs/{id}
DefaultApi	getQuestionConfigs	GET /api/v1/question-configs
DefaultApi	getQuestionResult	GET /api/v1/question-results/{id}
DefaultApi	getQuestionResults	GET /api/v1/question-results
DefaultApi	getSSOUserByEmail	GET /api/v1/sso-users/by-email/{email}
DefaultApi	getSSOUserById	GET /api/v1/sso-users/by-id/{id}
DefaultApi	getSSOUsers	GET /api/v1/sso-users
DefaultApi	getSubscriptions	GET /api/v1/subscriptions
DefaultApi	getTenant	GET /api/v1/tenants/{id}
DefaultApi	getTenantDailyUsages	GET /api/v1/tenant-daily-usage
DefaultApi	getTenantPackage	GET /api/v1/tenant-packages/{id}
DefaultApi	getTenantPackages	GET /api/v1/tenant-packages
DefaultApi	getTenantUser	GET /api/v1/tenant-users/{id}
DefaultApi	getTenantUsers	GET /api/v1/tenant-users
DefaultApi	getTenants	GET /api/v1/tenants
DefaultApi	getTicket	GET /api/v1/tickets/{id}
DefaultApi	getTickets	GET /api/v1/tickets
DefaultApi	getUser	GET /api/v1/users/{id}
DefaultApi	getUserBadge	GET /api/v1/user-badges/{id}
DefaultApi	getUserBadgeProgressById	GET /api/v1/user-badge-progress/{id}
DefaultApi	getUserBadgeProgressByUserId	GET /api/v1/user-badge-progress/user/{userId}
DefaultApi	getUserBadgeProgressList	GET /api/v1/user-badge-progress
DefaultApi	getUserBadges	GET /api/v1/user-badges
DefaultApi	getVotes	GET /api/v1/votes
DefaultApi	getVotesForUser	GET /api/v1/votes/for-user
DefaultApi	patchDomainConfig	PATCH /api/v1/domain-configs/{domainToUpdate}
DefaultApi	patchHashTag	PATCH /api/v1/hash-tags/{tag}
DefaultApi	patchPage	PATCH /api/v1/pages/{id}
DefaultApi	patchSSOUser	PATCH /api/v1/sso-users/{id}
DefaultApi	putDomainConfig	PUT /api/v1/domain-configs/{domainToUpdate}
DefaultApi	putSSOUser	PUT /api/v1/sso-users/{id}
DefaultApi	renderEmailTemplate	POST /api/v1/email-templates/render
DefaultApi	replaceTenantPackage	PUT /api/v1/tenant-packages/{id}
DefaultApi	replaceTenantUser	PUT /api/v1/tenant-users/{id}
DefaultApi	saveComment	POST /api/v1/comments
DefaultApi	saveCommentsBulk	POST /api/v1/comments/bulk
DefaultApi	sendInvite	POST /api/v1/moderators/{id}/send-invite
DefaultApi	sendLoginLink	POST /api/v1/tenant-users/{id}/send-login-link
DefaultApi	unBlockUserFromComment	POST /api/v1/comments/{id}/un-block
DefaultApi	unFlagComment	POST /api/v1/comments/{id}/un-flag
DefaultApi	updateComment	PATCH /api/v1/comments/{id}
DefaultApi	updateEmailTemplate	PATCH /api/v1/email-templates/{id}
DefaultApi	updateFeedPost	PATCH /api/v1/feed-posts/{id}
DefaultApi	updateModerator	PATCH /api/v1/moderators/{id}
DefaultApi	updateNotification	PATCH /api/v1/notifications/{id}
DefaultApi	updateQuestionConfig	PATCH /api/v1/question-configs/{id}
DefaultApi	updateQuestionResult	PATCH /api/v1/question-results/{id}
DefaultApi	updateSubscription	PATCH /api/v1/subscriptions/{id}
DefaultApi	updateTenant	PATCH /api/v1/tenants/{id}
DefaultApi	updateTenantPackage	PATCH /api/v1/tenant-packages/{id}
DefaultApi	updateTenantUser	PATCH /api/v1/tenant-users/{id}
DefaultApi	updateUserBadge	PUT /api/v1/user-badges/{id}
ModerationApi	deleteModerationVote	DELETE /auth/my-account/moderate-comments/mod_api/vote/{commentId}/{voteId}
ModerationApi	getApiComments	GET /auth/my-account/moderate-comments/mod_api/api/comments
ModerationApi	getApiExportStatus	GET /auth/my-account/moderate-comments/mod_api/api/export/status
ModerationApi	getApiIds	GET /auth/my-account/moderate-comments/mod_api/api/ids
ModerationApi	getBanUsersFromComment	GET /auth/my-account/moderate-comments/mod_api/ban-users/from-comment/{commentId}
ModerationApi	getCommentBanStatus	GET /auth/my-account/moderate-comments/mod_api/get-comment-ban-status/{commentId}
ModerationApi	getCommentChildren	GET /auth/my-account/moderate-comments/mod_api/comment-children/{commentId}
ModerationApi	getCount	GET /auth/my-account/moderate-comments/mod_api/count
ModerationApi	getCounts	GET /auth/my-account/moderate-comments/banned-users/mod_api/counts
ModerationApi	getLogs	GET /auth/my-account/moderate-comments/mod_api/logs/{commentId}
ModerationApi	getManualBadges	GET /auth/my-account/moderate-comments/mod_api/get-manual-badges
ModerationApi	getManualBadgesForUser	GET /auth/my-account/moderate-comments/mod_api/get-manual-badges-for-user
ModerationApi	getModerationComment	GET /auth/my-account/moderate-comments/mod_api/comment/{commentId}
ModerationApi	getModerationCommentText	GET /auth/my-account/moderate-comments/mod_api/get-comment-text/{commentId}
ModerationApi	getPreBanSummary	GET /auth/my-account/moderate-comments/mod_api/pre-ban-summary/{commentId}
ModerationApi	getSearchCommentsSummary	GET /auth/my-account/moderate-comments/mod_api/search/comments/summary
ModerationApi	getSearchPages	GET /auth/my-account/moderate-comments/mod_api/search/pages
ModerationApi	getSearchSites	GET /auth/my-account/moderate-comments/mod_api/search/sites
ModerationApi	getSearchSuggest	GET /auth/my-account/moderate-comments/mod_api/search/suggest
ModerationApi	getSearchUsers	GET /auth/my-account/moderate-comments/mod_api/search/users
ModerationApi	getTrustFactor	GET /auth/my-account/moderate-comments/mod_api/get-trust-factor
ModerationApi	getUserBanPreference	GET /auth/my-account/moderate-comments/mod_api/user-ban-preference
ModerationApi	getUserInternalProfile	GET /auth/my-account/moderate-comments/mod_api/get-user-internal-profile
ModerationApi	postAdjustCommentVotes	POST /auth/my-account/moderate-comments/mod_api/adjust-comment-votes/{commentId}
ModerationApi	postApiExport	POST /auth/my-account/moderate-comments/mod_api/api/export
ModerationApi	postBanUserFromComment	POST /auth/my-account/moderate-comments/mod_api/ban-user/from-comment/{commentId}
ModerationApi	postBanUserUndo	POST /auth/my-account/moderate-comments/mod_api/ban-user/undo
ModerationApi	postBulkPreBanSummary	POST /auth/my-account/moderate-comments/mod_api/bulk-pre-ban-summary
ModerationApi	postCommentsByIds	POST /auth/my-account/moderate-comments/mod_api/comments-by-ids
ModerationApi	postFlagComment	POST /auth/my-account/moderate-comments/mod_api/flag-comment/{commentId}
ModerationApi	postRemoveComment	POST /auth/my-account/moderate-comments/mod_api/remove-comment/{commentId}
ModerationApi	postRestoreDeletedComment	POST /auth/my-account/moderate-comments/mod_api/restore-deleted-comment/{commentId}
ModerationApi	postSetCommentApprovalStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-approval-status/{commentId}
ModerationApi	postSetCommentReviewStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-review-status/{commentId}
ModerationApi	postSetCommentSpamStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-spam-status/{commentId}
ModerationApi	postSetCommentText	POST /auth/my-account/moderate-comments/mod_api/set-comment-text/{commentId}
ModerationApi	postUnFlagComment	POST /auth/my-account/moderate-comments/mod_api/un-flag-comment/{commentId}
ModerationApi	postVote	POST /auth/my-account/moderate-comments/mod_api/vote/{commentId}
ModerationApi	putAwardBadge	PUT /auth/my-account/moderate-comments/mod_api/award-badge
ModerationApi	putCloseThread	PUT /auth/my-account/moderate-comments/mod_api/close-thread
ModerationApi	putRemoveBadge	PUT /auth/my-account/moderate-comments/mod_api/remove-badge
ModerationApi	putReopenThread	PUT /auth/my-account/moderate-comments/mod_api/reopen-thread
ModerationApi	setTrustFactor	PUT /auth/my-account/moderate-comments/mod_api/set-trust-factor
PublicApi	blockFromCommentPublic	POST /block-from-comment/{commentId}
PublicApi	checkedCommentsForBlocked	GET /check-blocked-comments
PublicApi	createCommentPublic	POST /comments/{tenantId}
PublicApi	createFeedPostPublic	POST /feed-posts/{tenantId}
PublicApi	createV1PageReact	POST /page-reacts/v1/likes/{tenantId}
PublicApi	createV2PageReact	POST /page-reacts/v2/{tenantId}
PublicApi	deleteCommentPublic	DELETE /comments/{tenantId}/{commentId}
PublicApi	deleteCommentVote	DELETE /comments/{tenantId}/{commentId}/vote/{voteId}
PublicApi	deleteFeedPostPublic	DELETE /feed-posts/{tenantId}/{postId}
PublicApi	deleteV1PageReact	DELETE /page-reacts/v1/likes/{tenantId}
PublicApi	deleteV2PageReact	DELETE /page-reacts/v2/{tenantId}
PublicApi	flagCommentPublic	POST /flag-comment/{commentId}
PublicApi	getCommentText	GET /comments/{tenantId}/{commentId}/text
PublicApi	getCommentVoteUserNames	GET /comments/{tenantId}/{commentId}/votes
PublicApi	getCommentsForUser	GET /comments-for-user
PublicApi	getCommentsPublic	GET /comments/{tenantId}	req tenantId urlId
PublicApi	getEventLog	GET /event-log/{tenantId}	req tenantId urlId userIdWS
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	req tenantId afterId
PublicApi	getFeedPostsStats	GET /feed-posts/{tenantId}/stats
PublicApi	getGifLarge	GET /gifs/get-large/{tenantId}
PublicApi	getGifsSearch	GET /gifs/search/{tenantId}
PublicApi	getGifsTrending	GET /gifs/trending/{tenantId}
PublicApi	getGlobalEventLog	GET /event-log/global/{tenantId}	req tenantId urlId userIdWS
PublicApi	getOfflineUsers	GET /pages/{tenantId}/users/offline	Commentaires précédents sur la page qui ne sont PAS actuellement en ligne. Triés par displayName. Utilisez ceci après avoir épuisé /users/online pour rendre une section "Members". Pagination par curseur sur commenterName : le serveur parcourt l'index partiel {tenantId, urlId, commenterName} à partir de afterName vers l'avant via $gt, aucun coût $skip.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	Visiteurs actuellement en ligne d’une page : les personnes dont la session websocket est abonnée à la page en ce moment. Retourne anonCount + totalCount (abonnés à la salle, y compris les visionneurs anonymes que nous n'énumérons pas).
PublicApi	getPagesPublic	GET /pages/{tenantId}	Liste les pages d’un locataire. Utilisé par le client de bureau FChat pour remplir sa liste de salles. Nécessite que `enableFChat` soit vrai dans la configuration personnalisée résolue pour chaque page. Les pages nécessitant SSO sont filtrées en fonction de l’accès au groupe de l’utilisateur demandeur.
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	Informations d’utilisateur en masse pour un locataire. Donnés userIds, retourne les informations d’affichage depuis User / SSOUser. Utilisé par le widget de commentaire pour enrichir les utilisateurs qui viennent d’apparaître via un événement de présence. Aucun contexte de page : la confidentialité est appliquée uniformément (les profils privés sont masqués).
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}	Activer ou désactiver les notifications pour un commentaire spécifique.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Activer ou désactiver les notifications pour une page. Lorsque les utilisateurs sont abonnés à une page, des notifications sont créées pour les nouveaux commentaires racine, et aussi
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Télécharger et redimensionner une image
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Documentation des modèles

aggregate

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

Paramètres

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

Réponse

Renvoie: AggregateResponse

Exemple

Exemple d'agrégation

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();
            // traiter la réponse
        } catch (const std::exception& e) {
            // gérer l'erreur
        }
    });

getAuditLogs

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
options	const GetAuditLogsOptions&	Yes

Réponse

Renvoie : GetAuditLogsResponse

Exemple

Exemple 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();
        // utilisez la réponse
    } catch (const std::exception& e) {
        // gérer l'erreur
    }
});

logoutPublic

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple logoutPublic

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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
publicBlockFromCommentParams	PublicBlockFromCommentParams	Oui
sso	string	Non

Réponse

Renvoie : BlockSuccess

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
publicBlockFromCommentParams	PublicBlockFromCommentParams	Oui
sso	string	Non

Réponse

Renvoie : UnblockSuccess

Exemple

unBlockCommentPublic Exemple

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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentIds	string	Yes
sso	string	No

Réponse

Retourne : CheckBlockedCommentsResponse

Exemple

Exemple checkedCommentsForBlocked

Copy

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

blockUserFromComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
blockFromCommentParams	BlockFromCommentParams	Yes
options	const BlockUserFromCommentOptions&	Yes

Réponse

Returns: BlockSuccess

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
broadcastId	string	Oui
commentData	CommentData	Oui
options	const CreateCommentPublicOptions&	Oui

Réponse

Renvoie : SaveCommentsResponseWithPresence

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
options	const DeleteCommentOptions&	Oui

Réponse

Retourne : DeleteCommentResult

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
broadcastId	string	Oui
options	const DeleteCommentPublicOptions&	Oui

Réponse

Retourne : PublicAPIDeleteCommentResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
voteId	string	Oui
urlId	string	Oui
broadcastId	string	Oui
options	const DeleteCommentVoteOptions&	Oui

Réponse

Renvoie : VoteDeleteResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
options	const FlagCommentOptions&	Yes

Réponse

Renvoie : FlagCommentResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : APIGetCommentResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
options	const GetCommentsOptions&	Yes

Réponse

Retourne : APIGetCommentsResponse

Exemple

Exemple 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();
        // utiliser la réponse au besoin
    } catch (const std::exception& e) {
        // gérer l'erreur
    }
});

getCommentsPublic

req tenantId urlId

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
options	const GetCommentsPublicOptions&	Oui

Réponse

Renvoie : GetCommentsResponseWithPresence_PublicComment_

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
options	const GetCommentTextOptions&	Yes

Réponse

Renvoie : PublicAPIGetCommentTextResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
dir	int32_t	Yes
sso	string	No

Réponse

Renvoie : GetCommentVoteUserNamesSuccessResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Réponse

Retourne : ChangeCommentPinStatusResponse

Exemple

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

Paramètres

Nom	Type	Requis
tenantId	string	Oui
createCommentParams	CreateCommentParams	Oui
options	const SaveCommentOptions&	Oui

Réponse

Retourne : APISaveCommentResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
commentTextUpdateRequest	CommentTextUpdateRequest	Yes
options	const SetCommentTextOptions&	Yes

Réponse

Renvoie : PublicAPISetCommentTextResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
unBlockFromCommentParams	UnBlockFromCommentParams	Oui
options	const UnBlockUserFromCommentOptions&	Oui

Réponse

Retourne : UnblockSuccess

Exemple

Exemple de unBlockUserFromComment

Copy

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

unFlagComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
options	const UnFlagCommentOptions&	Oui

Réponse

Renvoie : FlagCommentResponse

Exemple

Exemple de 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;
            // process status if needed
        }
    })
    .then([](pplx::task<void> previous) {
        try {
            previous.get();
        } catch (const std::exception& e) {
            // handle error
        }
    });

unLockComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
broadcastId	string	Oui
sso	string	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de unLockComment

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("cmt-456789");
auto broadcastId = utility::conversions::to_string_t("broadcast-001");
boost::optional<utility::string_t> sno = 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
broadcastId	string	Oui
sso	string	Non

Réponse

Renvoie : ChangeCommentPinStatusResponse

Exemple

Exemple de unPinComment

Copy

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

updateComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
updatableCommentParams	UpdatableCommentParams	Yes
options	const UpdateCommentOptions&	Yes

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de updateComment

Copy

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

voteComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
urlId	string	Oui
broadcastId	string	Oui
voteBodyParams	VoteBodyParams	Oui
options	const VoteCommentOptions&	Oui

Réponse

Renvoie : VoteResponse

Exemple

Exemple 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();
           // gérer la réponse
       } catch (const std::exception&) {
       }
   });

getCommentsForUser

Paramètres

Nom	Type	Requis	Description
options	const GetCommentsForUserOptions&	Oui

Réponse

Renvoie : GetCommentsForUserResponse

Exemple

Exemple getCommentsForUser

Copy

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

addDomainConfig

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
addDomainConfigParams	AddDomainConfigParams	Oui

Réponse

Renvoie : AddDomainConfigResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
domain	string	Oui

Réponse

Renvoie: DeleteDomainConfigResponse

Exemple

Exemple deleteDomainConfig

Copy

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

getDomainConfig

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
domain	string	Oui

Réponse

Renvoie : GetDomainConfigResponse

Exemple

Exemple 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) {
            // gérer la modération activée
        }
        if (theme) {
            // utiliser la valeur du thème
        }
    })
    .wait();

getDomainConfigs

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui

Réponse

Renvoie : GetDomainConfigsResponse

Exemple

Exemple getDomainConfigs

Copy

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

patchDomainConfig

Parameters

Nom	Type	Obligatoire
tenantId	string	Oui
domainToUpdate	string	Oui
patchDomainConfigParams	PatchDomainConfigParams	Oui

Réponse

Retourne : PatchDomainConfigResponse

Exemple

Exemple 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) {
        // gestion du succès
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* gestion de l'erreur */ }
    });

putDomainConfig

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
domainToUpdate	string	Oui
updateDomainConfigParams	UpdateDomainConfigParams	Oui

Réponse

Renvoie : PutDomainConfigResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Requis	Description
tenantId	string	Yes
createEmailTemplateBody	CreateEmailTemplateBody	Yes

Réponse

Retourne : CreateEmailTemplateResponse

Exemple

Exemple createEmailTemplate

Copy

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

deleteEmailTemplate

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
errorId	string	Yes

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple deleteEmailTemplateRenderError

Copy

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

getEmailTemplate

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : GetEmailTemplateResponse

Exemple

Exemple getEmailTemplate

Copy

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

getEmailTemplateDefinitions

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui

Réponse

Retourne : GetEmailTemplateDefinitionsResponse

Exemple

Exemple 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

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
skip	double	No

Response

Returns: GetEmailTemplateRenderErrorsResponse

Example

getEmailTemplateRenderErrors Exemple

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();
            // Utiliser la réponse selon les besoins
        } catch (const std::exception& ex) {
            // Gérer l'erreur
        }
    });

getEmailTemplates

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
skip	double	Non

Réponse

Renvoie : GetEmailTemplatesResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
renderEmailTemplateBody	RenderEmailTemplateBody	Oui
locale	string	Non

Réponse

Retourne : RenderEmailTemplateResponse

Exemple

Exemple renderEmailTemplate

Copy

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

updateEmailTemplate

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateEmailTemplateBody	UpdateEmailTemplateBody	Oui

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de updateEmailTemplate

Copy

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

getEventLog

req tenantId urlId userIdWS

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
userIdWS	string	Oui
startTime	int64_t	Oui
endTime	int64_t	Non

Réponse

Returns: GetEventLogResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
urlId	string	Yes
userIdWS	string	Yes
startTime	int64_t	Yes
endTime	int64_t	No

Réponse

Renvoie : GetEventLogResponse

Exemple

getGlobalEventLog Exemple

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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
options	const CreateFeedPostOptions&	Yes

Réponse

Retourne : CreateFeedPostsResponse

Exemple

Exemple createFeedPost

Copy

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

createFeedPostPublic

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
options	const CreateFeedPostPublicOptions&	Yes

Réponse

Renvoie : CreateFeedPostResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
postId	string	Oui
options	const DeleteFeedPostPublicOptions&	Oui

Réponse

Retourne : DeleteFeedPostPublicResponse

Exemple

Exemple deleteFeedPostPublic

Copy

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

getFeedPosts

req tenantId afterId

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetFeedPostsOptions&	Oui

Réponse

Renvoie : GetFeedPostsResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
options	const GetFeedPostsPublicOptions&	Yes

Réponse

Retourne : PublicFeedPostsResponse

Exemple

Exemple 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);
        // Utilisez processed selon les besoins
    }catch(const std::exception&){
        // Gérer l'erreur
    }
});

getFeedPostsStats

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
postIds	vector<string	Oui
sso	string	Non

Réponse

Renvoie : FeedPostsStatsResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetUserReactsPublicOptions&	Oui

Réponse

Renvoie : UserReactsResponse

Exemple

Exemple getUserReactsPublic

Copy

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

reactFeedPostPublic

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
postId	string	Yes
reactBodyParams	ReactBodyParams	Yes
options	const ReactFeedPostPublicOptions&	Yes

Réponse

Renvoie : ReactFeedPostResponse

Exemple

Exemple reactFeedPostPublic

Copy

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

updateFeedPost

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
feedPost	FeedPost	Yes

Réponse

Retourne : APIEmptyResponse

Exemple

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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
postId	string	Oui
updateFeedPostParams	UpdateFeedPostParams	Oui
options	const UpdateFeedPostPublicOptions&	Oui

Réponse

Renvoie : CreateFeedPostResponse

Exemple

Exemple de updateFeedPostPublic

Copy

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

flagCommentPublic

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
isFlagged	bool	Oui
sso	string	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple flagCommentPublic

Copy

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

getGifLarge

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
largeInternalURLSanitized	string	Oui

Réponse

Renvoie : GifGetLargeResponse

Exemple

Exemple getGifLarge

Copy

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

getGifsSearch

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
search	string	Oui
options	const GetGifsSearchOptions&	Oui

Réponse

Renvoie : GetGifsSearchResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Requis	Description
tenantId	string	Oui
options	const GetGifsTrendingOptions&	Oui

Réponse

Retourne : GetGifsTrendingResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createHashTagBody	CreateHashTagBody	Oui

Réponse

Renvoie : CreateHashTagResponse

Exemple

addHashTag Exemple

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

Paramètres

Name	Type	Required	Description
tenantId	string	Yes
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Yes

Réponse

Renvoie : BulkCreateHashTagsResponse

Exemple

addHashTagsBulk Exemple

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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
tag	string	Oui
deleteHashTagRequestBody	DeleteHashTagRequestBody	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple deleteHashTag

Copy

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

---

getHashTags

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
page	double	Non

Réponse

Renvoie : GetHashTagsResponse

Exemple

Exemple 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);
        // utiliser la réponse
    } catch (const std::exception&) {
        // gérer l'erreur
    }
});

patchHashTag

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
tag	string	Yes
updateHashTagBody	UpdateHashTagBody	Yes

Réponse

Renvoie : UpdateHashTagResponse

Exemple

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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
voteId	string	Oui
options	const DeleteModerationVoteOptions&	Oui

Réponse

Retourne : VoteDeleteResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
options	const GetApiCommentsOptions&	Yes

Réponse

Renvoie : ModerationAPIGetCommentsResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetApiExportStatusOptions&	Oui

Réponse

Renvoie : ModerationExportStatusResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
options	const GetApiIdsOptions&	Yes

Réponse

Renvoie : ModerationAPIGetCommentIdsResponse

Exemple

Exemple getApiIds

Copy

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

getBanUsersFromComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
sso	string	Non

Réponse

Renvoie : GetBannedUsersFromCommentResponse

Exemple

Exemple getBanUsersFromComment

Copy

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

getCommentBanStatus

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
sso	string	Non

Réponse

Retourne : GetCommentBanStatusResponse

Exemple

Exemple getCommentBanStatus

Copy

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

getCommentChildren

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
sso	string	Non

Réponse

Retourne : ModerationAPIChildCommentsResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetCountOptions&	Oui

Réponse

Renvoie : ModerationAPICountCommentsResponse

Exemple

getCount Exemple

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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
sso	string	Non

Réponse

Retourne : GetBannedUsersCountResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Requis
tenantId	string	Oui
commentId	string	Oui
sso	string	Non

Réponse

Renvoie : ModerationAPIGetLogsResponse

Exemple

Exemple getLogs

Copy

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

getManualBadges

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
sso	string	Non

Réponse

Retourne : GetTenantManualBadgesResponse

Exemple

Exemple 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();
            // traiter la réponse, p. ex., response->badgeList
        } catch (const std::exception& ex) {
            // gérer l'erreur
        }
    });

getManualBadgesForUser

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetManualBadgesForUserOptions&	Oui

Réponse

Renvoie : GetUserManualBadgesResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
options	const GetModerationCommentOptions&	Yes

Réponse

Retourne : ModerationAPICommentResponse

Exemple

Exemple 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();
            // Traiter la réponse selon les besoins
        } catch (const std::exception& ex) {
            // Gérer l'erreur
        }
    });

getModerationCommentText

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
sso	string	Non

Réponse

Renvoie : GetCommentTextResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
options	const GetPreBanSummaryOptions&	Oui

Réponse

Renvoie : PreBanSummary

Exemple

Exemple 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();
            // traiter le résumé
        } catch (const std::exception&) {
            // gérer l'erreur
        }
    });

getSearchCommentsSummary

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetSearchCommentsSummaryOptions&	Oui

Réponse

Renvoie : ModerationCommentSearchResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetSearchPagesOptions&	Oui

Réponse

Retourne : ModerationPageSearchResponse

Exemple

Exemple 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();
            // utilisez la réponse
        } catch (const std::exception& e) {
            // gérer l'erreur
        }
    });

getSearchSites

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetSearchSitesOptions&	Oui

Réponse

Retourne : ModerationSiteSearchResponse

Exemple

Exemple getSearchSites

Copy

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

getSearchSuggest

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
options	const GetSearchSuggestOptions&	Yes

Réponse

Renvoie : ModerationSuggestResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
options	const GetSearchUsersOptions&	Yes

Réponse

Retourne : ModerationUserSearchResponse

Exemple

getSearchUsers Exemple

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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetTrustFactorOptions&	Oui

Réponse

Retourne : GetUserTrustFactorResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
sso	string	Non

Réponse

Renvoie : APIModerateGetUserBanPreferencesResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetUserInternalProfileOptions&	Oui

Réponse

Renvoie : GetUserInternalProfileResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
adjustCommentVotesParams	AdjustCommentVotesParams	Oui
options	const PostAdjustCommentVotesOptions&	Oui

Réponse

Renvoie : AdjustVotesResponse

Exemple

Exemple 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

Paramètres

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

Réponse

Retourne : ModerationExportResponse

Exemple

Exemple 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) {
            // gérer la réponse d'exportation réussie
        }
    })
    .wait();

postBanUserFromComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
options	const PostBanUserFromCommentOptions&	Oui

Réponse

Renvoie : BanUserFromCommentResult

Exemple

postBanUserFromComment Exemple

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) {
        // traitement du résultat
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* gestion des erreurs */ }
    });

postBanUserUndo

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
banUserUndoParams	BanUserUndoParams	Oui
sso	string	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple 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){
    // handle success
});

postBulkPreBanSummary

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
bulkPreBanParams	BulkPreBanParams	Oui
options	const PostBulkPreBanSummaryOptions&	Oui

Réponse

Renvoie : BulkPreBanSummary

Exemple

postBulkPreBanSummary Exemple

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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentsByIdsParams	CommentsByIdsParams	Oui
sso	string	Non

Réponse

Renvoie : ModerationAPIChildCommentsResponse

Exemple

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

Paramètres

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

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
options	const PostRemoveCommentOptions&	Yes

Réponse

Renvoie : PostRemoveCommentApiResponse

Exemple

Exemple 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();
            // Traiter la réponse
        } catch (const std::exception& ex) {
            // Gérer l'erreur
        }
    });

postRestoreDeletedComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
options	const PostRestoreDeletedCommentOptions&	Yes

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
options	const PostSetCommentApprovalStatusOptions&	Oui

Réponse

Renvoie : SetCommentApprovedResponse

Exemple

postSetCommentApprovalStatus Exemple

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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
options	const PostSetCommentReviewStatusOptions&	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple postSetCommentReviewStatus

Copy

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

postSetCommentSpamStatus

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentSpamStatusOptions&	Yes

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple postSetCommentSpamStatus

Copy

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

postSetCommentText

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
setCommentTextParams	SetCommentTextParams	Yes
options	const PostSetCommentTextOptions&	Yes

Réponse

Renvoie : SetCommentTextResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
options	const PostUnFlagCommentOptions&	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple postUnFlagComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
PostUnFlagCommentOptions opts;
opts.notifyUser = boost::optional<bool>(true);
api->postUnFlagComment(tenantId, commentId, opts)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // le traitement peut être effectué ici
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

postVote

Paramètres

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

Réponse

Renvoie : VoteResponse

Exemple

Exemple postVote

Copy

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

putAwardBadge

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
badgeId	string	Yes
options	const PutAwardBadgeOptions&	Yes

Réponse

Renvoie : AwardUserBadgeResponse

Exemple

Exemple putAwardBadge

Copy

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

putCloseThread

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
urlId	string	Yes
sso	string	No

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple putCloseThread

Copy

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

putRemoveBadge

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
badgeId	string	Oui
options	const PutRemoveBadgeOptions&	Oui

Réponse

Renvoie : RemoveUserBadgeResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
sso	string	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

putReopenThread Exemple

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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const SetTrustFactorOptions&	Oui

Réponse

Renvoie : SetUserTrustFactorResponse

Exemple

Exemple 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

Paramètres

Name	Type	Required	Description
tenantId	string	Yes
createModeratorBody	CreateModeratorBody	Yes

Réponse

Retourne : CreateModeratorResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
sendEmail	string	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de suppression de modérateur

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) {
        // gérer le succès
    });

getModerator

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : GetModeratorResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Requis	Description
tenantId	string	Oui
skip	double	Non

Réponse

Renvoie : GetModeratorsResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
fromName	string	Oui

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple 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) {
    // traiter l'invitation réussie
});

updateModerator

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateModeratorBody	UpdateModeratorBody	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de updateModerator

Copy

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

deleteNotificationCount

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : GetCachedNotificationCountResponse

Exemple

Exemple de 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();
            // traiter la réponse
        } catch (const std::exception&) {
            // gérer l'erreur
        }
    });

getNotificationCount

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetNotificationCountOptions&	Oui

Réponse

Renvoie : GetNotificationCountResponse

Exemple

getNotificationCount Exemple

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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetNotificationsOptions&	Oui

Réponse

Renvoie : GetNotificationsResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
updateNotificationBody	UpdateNotificationBody	Yes
userId	string	No

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de updateNotification

Copy

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

createV1PageReact

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
urlId	string	Yes
title	string	No

Réponse

Renvoie : CreateV1PageReact

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
id	string	Oui
title	string	Non

Réponse

Renvoie : CreateV1PageReact

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
urlId	string	Oui

Réponse

Retourne : CreateV1PageReact

Exemple

deleteV1PageReact Exemple

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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
urlId	string	Yes
id	string	Yes

Réponse

Renvoie : CreateV1PageReact

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
urlId	string	Yes

Réponse

Renvoie : GetV1PageLikes

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
urlId	string	Oui

Réponse

Renvoie : GetV2PageReacts

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
id	string	Oui

Réponse

Renvoie : GetV2PageReactUsersResponse

Exemple

Exemple 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();
        // Utiliser la réponse selon les besoins
    }catch(const std::exception&){
        // Gérer l'erreur
    }
});

addPage

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createAPIPageData	CreateAPIPageData	Oui

Réponse

Renvoie : AddPageAPIResponse

Exemple

Exemple 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) {
            // gérer l'ajout réussi
        } else {
            // gérer l'erreur
        }
    });

deletePage

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : DeletePageAPIResponse

Exemple

deletePage Exemple

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();
           // traiter la réponse selon les besoins
       } catch (const std::exception& ex) {
           // gérer l'erreur
       }
   });

getOfflineUsers

Commentateurs passés sur la page qui ne sont PAS actuellement en ligne. Triés par displayName.
Utilisez ceci après avoir épuisé /users/online pour afficher une section « Membres ».
Pagination par curseur sur commenterName : le serveur parcourt la partie {tenantId, urlId, commenterName}
index à partir de afterName en avançant via $gt, aucun coût $skip.

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
options	const GetOfflineUsersOptions&	Oui

Réponse

Renvoie : PageUsersOfflineResponse

Exemple

Exemple 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

Actuellement‑en‑ligne les visualiseurs d’une page : les personnes dont la session websocket est abonnée à la page à l’instant présent.
Renvoie anonCount + totalCount (abonnés à toute la salle, incluant les visualiseurs anonymes que nous n’énumérons pas).

Paramètres

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
options	const GetOnlineUsersOptions&	Yes

Réponse

Renvoie : PageUsersOnlineResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
urlId	string	Yes

Réponse

Returns: GetPageByURLIdAPIResponse

Exemple

Exemple getPageByURLId

Copy

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

getPages

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui

Réponse

Renvoie : GetPagesAPIResponse

Exemple

Exemple getPages

Copy

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

getPagesPublic

List pages for a tenant. Used by the FChat desktop client to populate its room list.
Requires enableFChat to be true on the resolved custom config for each page.
Pages that require SSO are filtered against the requesting user's group access.

Parameters

Nom	Type	Requis	Description
tenantId	string	Oui
options	const GetPagesPublicOptions&	Oui

Réponse

Renvoie : GetPublicPagesResponse

Exemple

Exemple 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();
        // traiter la réponse si nécessaire
    }catch(const std::exception&){
        // gérer l'erreur si nécessaire
    }
});

getUsersInfo

Informations d'utilisateurs en masse pour un locataire. Étant donné des userIds, renvoie les informations d'affichage du User / SSOUser. Utilisé par le widget de commentaire pour enrichir les utilisateurs qui viennent d'apparaître via un événement de présence. Pas de contexte de page : la confidentialité est appliquée uniformément (les profils privés sont masqués).

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
ids	string	Oui

Réponse

Renvoie : PageUsersInfoResponse

Exemple

Exemple getUsersInfo

Copy

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

patchPage

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateAPIPageData	UpdateAPIPageData	Oui

Réponse

Renvoie : PatchPageAPIResponse

Exemple

Exemple patchPage

Copy

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

deletePendingWebhookEvent

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de deletePendingWebhookEvent

Copy

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

getPendingWebhookEventCount

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetPendingWebhookEventCountOptions&	Oui

Réponse

Renvoie : GetPendingWebhookEventCountResponse

Exemple

getPendingWebhookEventCount Exemple

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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetPendingWebhookEventsOptions&	Oui

Réponse

Retourne : GetPendingWebhookEventsResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createQuestionConfigBody	CreateQuestionConfigBody	Oui

Réponse

Renvoie : CreateQuestionConfigResponse

Exemple

Exemple createQuestionConfig

Copy

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

deleteQuestionConfig

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de 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) {
        // gérer la suppression réussie
    })
    .then([](pplx::task<void> t) {
        try {
            t.get();
        } catch (const std::exception&) {
            // gérer l'erreur
        }
    });

getQuestionConfig

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : GetQuestionConfigResponse

Exemple

Exemple getQuestionConfig

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto questionId = utility::conversions::to_string_t("question-456");
api->getQuestionConfig(tenantId, questionId)
    .then([](pplx::task<std::shared_ptr<GetQuestionConfigResponse>> task) {
        try {
            auto response = task.get();
            // Use response as needed
        } catch (const std::exception&) {
            // Handle error
        }
    });

getQuestionConfigs

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
skip	double	No

Réponse

Renvoie : GetQuestionConfigsResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateQuestionConfigBody	UpdateQuestionConfigBody	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de updateQuestionConfig

Copy

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

createQuestionResult

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createQuestionResultBody	CreateQuestionResultBody	Oui

Réponse

Renvoie : CreateQuestionResultResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de 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();
                // gestion du succès
            }
            catch ( const std::exception& e )
            {
                // gestion de l'erreur
            }
        } );
}

getQuestionResult

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : GetQuestionResultResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetQuestionResultsOptions&	Oui

Réponse

Retourne : GetQuestionResultsResponse

Exemple

getQuestionResults Exemple

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();
        // gérer la réponse
    });

updateQuestionResult

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateQuestionResultBody	UpdateQuestionResultBody	Oui

Réponse

Renvoie : APIEmptyResponse

Exemple

updateQuestionResult Exemple

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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const AggregateQuestionResultsOptions&	Oui

Réponse

Retourne : AggregateQuestionResultsResponse

Exemple

aggregateQuestionResults Exemple

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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Yes
forceRecalculate	bool	No

Réponse

Renvoie : BulkAggregateQuestionResultsResponse

Exemple

Exemple bulkAggregateQuestionResults

Copy

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

combineCommentsWithQuestionResults

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const CombineCommentsWithQuestionResultsOptions&	Oui

Réponse

Retourne : CombineQuestionResultsWithCommentsResponse

Exemple

Exemple 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);
            // Utilisez « combined » selon les besoins
        }catch(const std::exception&){
        }
    });

addSSOUser

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
createAPISSOUserData	CreateAPISSOUserData	Yes

Réponse

Renvoie : AddSSOUserAPIResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
options	const DeleteSSOUserOptions&	Oui

Réponse

Renvoie : DeleteSSOUserAPIResponse

Exemple

deleteSSOUser Exemple

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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
email	string	Oui

Réponse

Retourne : GetSSOUserByEmailAPIResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : GetSSOUserByIdAPIResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
skip	int32_t	Non

Réponse

Retourne : GetSSOUsersResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
updateAPISSOUserData	UpdateAPISSOUserData	Yes
updateComments	bool	No

Réponse

Renvoie : PatchSSOUserAPIResponse

Exemple

Exemple patchSSOUser

Copy

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

putSSOUser

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
updateAPISSOUserData	UpdateAPISSOUserData	Yes
updateComments	bool	No

Réponse

Retourne : PutSSOUserAPIResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Oui

Réponse

Renvoie : CreateSubscriptionAPIResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Requis
tenantId	string	Oui
id	string	Oui
userId	string	Non

Réponse

Retourne : DeleteSubscriptionAPIResponse

Exemple

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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
userId	string	Non

Réponse

Retourne : GetSubscriptionsAPIResponse

Exemple

Exemple 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();
            // traiter la réponse
        } catch (const std::exception& e) {
            // gérer l'erreur
        }
    }
);

updateSubscription

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	Oui
userId	string	Non

Réponse

Retourne : UpdateSubscriptionAPIResponse

Exemple

updateSubscription Exemple

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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetTenantDailyUsagesOptions&	Oui

Réponse

Retourne : GetTenantDailyUsagesResponse

Exemple

Exemple getTenantDailyUsages

Copy

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

createTenantPackage

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createTenantPackageBody	CreateTenantPackageBody	Oui

Réponse

Retourne : CreateTenantPackageResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
id	string	Yes

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : GetTenantPackageResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
skip	double	Non

Réponse

Renvoie : GetTenantPackagesResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
replaceTenantPackageBody	ReplaceTenantPackageBody	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de replaceTenantPackage

Copy

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

updateTenantPackage

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
updateTenantPackageBody	UpdateTenantPackageBody	Yes

Réponse

Returns: APIEmptyResponse

Exemple

Exemple 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();
            // traitement du succès
        } catch (const std::exception& ex) {
            // traitement de l'erreur
        }
    });

createTenantUser

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createTenantUserBody	CreateTenantUserBody	Oui

Réponse

Renvoie : CreateTenantUserResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
options	const DeleteTenantUserOptions&	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

deleteTenantUser Exemple

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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : GetTenantUserResponse

Exemple

Exemple 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();
            // Utilisez la réponse selon les besoins
        } catch (const std::exception&) {
            // Gestion des erreurs
        }
    });

getTenantUsers

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
skip	double	Non

Réponse

Renvoie : GetTenantUsersResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
replaceTenantUserBody	ReplaceTenantUserBody	Yes
updateComments	string	No

Réponse

Renvoie : APIEmptyResponse

Exemple

replaceTenantUser Exemple

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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
redirectURL	string	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateTenantUserBody	UpdateTenantUserBody	Oui
updateComments	string	Non

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple updateTenantUser

Copy

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

createTenant

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createTenantBody	CreateTenantBody	Oui

Réponse

Retourne: CreateTenantResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
sure	string	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple 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

Paramètres

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Réponse

Retourne : GetTenantResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetTenantsOptions&	Oui

Réponse

Retourne : GetTenantsResponse

Exemple

Exemple 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

Paramètres

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

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
userId	string	Yes
id	string	Yes
changeTicketStateBody	ChangeTicketStateBody	Yes

Réponse

Renvoie : ChangeTicketStateResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
userId	string	Oui
createTicketBody	CreateTicketBody	Oui

Réponse

Retourne: CreateTicketResponse

Exemple

Exemple 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();
        // Utiliser la réponse au besoin
    }catch(const std::exception&){
        // Gérer l'erreur
    }
});

getTicket

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
userId	string	Non

Réponse

Renvoie : GetTicketResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetTicketsOptions&	Oui

Réponse

Renvoie : GetTicketsResponse

Exemple

getTickets Exemple

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

Paramètres

Nom	Type	Obligatoire
r_namespace	string	Oui
component	string	Oui
options	const GetTranslationsOptions&	Oui

Réponse

Renvoie : GetTranslationsResponse

Exemple

Exemple 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

Téléverser et redimensionner une image

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
file	HttpContent	Yes
options	const UploadImageOptions&	Yes

Réponse

Retourne : UploadImageResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : APIGetUserBadgeProgressResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
userId	string	Oui

Réponse

Retourne : APIGetUserBadgeProgressResponse

Exemple

Exemple getUserBadgeProgressByUserId

Copy

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

getUserBadgeProgressList

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetUserBadgeProgressListOptions&	Oui

Réponse

Renvoie : APIGetUserBadgeProgressListResponse

Exemple

Exemple 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) {
            // traiter le badge
        }
    });

createUserBadge

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createUserBadgeParams	CreateUserBadgeParams	Oui

Réponse

Renvoie : APICreateUserBadgeResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
id	string	Yes

Réponse

Retourne : APIEmptySuccessResponse

Exemple

deleteUserBadge Exemple

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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : APIGetUserBadgeResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetUserBadgesOptions&	Oui

Réponse

Retourne : APIGetUserBadgesResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
updateUserBadgeParams	UpdateUserBadgeParams	Yes

Réponse

Renvoie : APIEmptySuccessResponse

Exemple

Exemple de mise à jour du badge d'utilisateur

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

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
sso	string	Non

Réponse

Retourne : GetUserNotificationCountResponse

Exemple

Exemple 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, sno).then([](pplx::task<std::shared_ptr<GetUserNotificationCountResponse>> t){
    try{
        auto resp = t.get();
        // utilisez la réponse selon vos besoins
    }catch(const std::exception&){
        // gérer l'erreur
    }
});

getUserNotifications

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
options	const GetUserNotificationsOptions&	Oui

Réponse

Renvoie : GetMyNotificationsResponse

Exemple

Exemple getUserNotifications

Copy

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

resetUserNotificationCount

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
sso	string	Non

Réponse

Retourne : ResetUserNotificationsResponse

Exemple

Exemple de resetUserNotificationCount

Copy

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

resetUserNotifications

Parameters

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

Response

Retourne : ResetUserNotificationsResponse

Example

Exemple resetUserNotifications

Copy

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

updateUserNotificationCommentSubscriptionStatus

Activez ou désactivez les notifications pour un commentaire spécifique.

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
notificationId	string	Oui
optedInOrOut	string	Oui
commentId	string	Oui
sso	string	Non

Réponse

Renvoie : UpdateUserNotificationCommentSubscriptionStatusResponse

Exemple

updateUserNotificationCommentSubscriptionStatus Exemple

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

Activer ou désactiver les notifications pour une page. Lorsque les utilisateurs sont abonnés à une page, des notifications sont créées pour les nouveaux commentaires racine, et aussi

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
urlId	string	Yes
url	string	Yes
pageTitle	string	Yes
subscribedOrUnsubscribed	string	Yes
sso	string	No

Réponse

Renvoie : UpdateUserNotificationPageSubscriptionStatusResponse

Exemple

Exemple 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) {
        // process resp if needed
    });

updateUserNotificationStatus

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
notificationId	string	Yes
newStatus	string	Yes
sso	string	No

Réponse

Retourne : UpdateUserNotificationStatusResponse

Exemple

Exemple de updateUserNotificationStatus

Copy

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

getUserPresenceStatuses

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlIdWS	string	Oui
userIds	string	Oui

Réponse

Renvoie : GetUserPresenceStatusesResponse

Exemple

Exemple 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

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
options	const SearchUsersOptions&	Oui

Réponse

Retourne : SearchUsersResult

Exemple

Exemple 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

Paramètres

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Réponse

Renvoie : GetUserResponse

Exemple

Exemple 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>();
            }
            // traiter la réponse au besoin
        } catch (const std::exception&) {
            // gérer l'erreur
        }
    });

createVote

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
direction	string	Oui
options	const CreateVoteOptions&	Oui

Réponse

Renvoie : VoteResponse

Exemple

Exemple 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

Paramètres

Name	Type	Required
tenantId	string	Yes
id	string	Yes
editKey	string	No

Réponse

Retourne : VoteDeleteResponse

Exemple

Exemple 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();
        // Traiter la réponse selon les besoins
    } catch (const std::exception&) {
        // Gérer l’erreur
    }
});

getVotes

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
urlId	string	Oui

Réponse

Renvoie : GetVotesResponse

Exemple

Exemple 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 (...) {
        // error handling
    }
});

getVotesForUser

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
options	const GetVotesForUserOptions&	Oui

Réponse

Renvoie : GetVotesForUserResponse

Exemple

Exemple 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) {
        // gérer la réponse, p. ex., parcourir les votes
    }
});

Besoin d'aide ?

Si vous rencontrez des problèmes ou avez des questions concernant le SDK C++, veuillez :

Contribuer

Les contributions sont les bienvenues ! Veuillez consulter le dépôt GitHub pour les directives de contribution.

Langue 🇨🇦 Français (Canada)

Documentation

Premiers pas

Référence API

Utilisation

Agrégation

Journaux d'audit

Authentification

Blocage par commentaire

Vérifier les commentaires bloqués

Commentaires

Commentaires pour l'utilisateur

Configurations de domaine

Modèles d'e-mail

Journal des événements

Publications

Signaler un commentaire

GIFs

Mots-clics

Modération

Modérateurs

Nombre de notifications

Notifications

Réactions de page

Pages

Événements webhook en attente

Configurations de questions

Résultats de questions

Agrégation des résultats de questions

Utilisateurs SSO

Abonnements

Utilisation quotidienne du locataire

Forfaits du locataire

Utilisateurs du locataire

Locataires

Tickets

Traductions

Téléverser une image

Progression des badges utilisateur

Badges utilisateur

Notifications utilisateur

Statut de présence de l'utilisateur

Recherche d'utilisateurs

Utilisateurs

Votes

SDK C++ de FastComments

Dépôt

Prérequis

Installation

Installer les dépendances

Compiler à partir du code source

Installation

Contenu de la bibliothèque

API publiques vs sécurisées

Démarrage rapide

Utilisation des API authentifiées (DefaultAPI)

Utilisation des API publiques (PublicAPI)

Utilisation des API de modération (ModerationApi)

Problèmes courants

Appels d'API : synchrones vs asynchrones

Appels synchrones avec .get()

Appels asynchrones avec .then()

Choisir entre synchrone et asynchrone

Remarques

Identifiants de diffusion

SSO (Authentification unique)

Utilisation du SSO

SSO simple

SSO sécurisé

Documentation pour FastComments

Documentation des points de terminaison d'API

Documentation des modèles

aggregate

Paramètres

Réponse

Exemple

getAuditLogs

Paramètres

Réponse

Exemple

Appels synchrones avec `.get()`

Appels asynchrones avec `.then()`