FastComments C++ SDK

Oto oficjalne SDK C++ dla FastComments.

Oficjalne SDK C++ dla API FastComments

Repozytorium

Agenci kodowania AI

Daj swojemu agentowi kodującemu kontekst FastComments, którego potrzebuje - widżety, konfiguracja, Secure SSO, REST API i SDK:

npx skills add fastcomments/skills

Działa z Claude Code, Codex, Cursor, Copilot, Gemini i każdym innym agentem, który obsługuje skills CLI.

Wymagania

C++17 lub nowszy
CMake 3.14 lub nowszy
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (automatycznie pobierany do testów)

Instalacja

Instalacja zależności

sudo apt install libcpprest-dev libboost-all-dev

Budowanie ze źródła

mkdir build
cd build
cmake ..
make

Instalacja

sudo make install

Zawartość biblioteki

Ta biblioteka zawiera wygenerowanego klienta API oraz narzędzia SSO, które ułatwiają pracę z API.

API Client Library Docs

Publiczne vs Zabezpieczone API

Dla klienta API istnieją trzy klasy: DefaultApi, PublicApi i ModerationApi. DefaultApi zawiera metody, które wymagają klucza API, a PublicApi zawiera metody, które mogą być wywoływane bezpośrednio z przeglądarki/urządzenia mobilnego itp. bez uwierzytelnienia. ModerationApi oferuje rozbudowany zestaw szybkich i bieżących interfejsów moderacji. Każda metoda ModerationApi przyjmuje parametr sso i może uwierzytelnić się za pomocą SSO lub pliku cookie sesji FastComments.com.

Szybki start

Using Authenticated APIs (DefaultAPI)

Ważne:

Musisz ustawić podstawowy URL (generator cpp-restsdk nie odczytuje go z specyfikacji OpenAPI)
Musisz ustawić swój klucz API w ApiClient przed wykonywaniem uwierzytelnionych żądań. Jeśli tego nie zrobisz, żądania zakończą się błędem 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>();

    // WYMAGANE: Ustaw podstawowy URL (wybierz swój region)
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));  // US
    // LUB: config->setBaseUrl(utility::conversions::to_string_t("https://eu.fastcomments.com"));  // EU

    // WYMAGANE: Ustaw swój klucz API
    config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_API_KEY_HERE"));

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

    // Teraz wykonaj uwierzytelnione wywołania API
    return 0;
}

Using Public APIs (PublicAPI)

Publiczne endpointy nie wymagają uwierzytelnienia:

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

    // WYMAGANE: Ustaw podstawowy 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);

    // Wykonaj publiczne wywołania API
    return 0;
}

Using Moderation APIs (ModerationApi)

API ModerationApi napędza panel moderatora. Każda metoda przyjmuje parametr sso, więc wywołanie jest wykonywane w imieniu moderatora uwierzytelnionego przez SSO (zobacz sekcję SSO poniżej, aby dowiedzieć się, jak utworzyć token):

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

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

    // WYMAGANE: Ustaw podstawowy 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);

    // Przekaż token SSO moderatora, aby uwierzytelnić wywołanie
    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;
}

Common Issues

Błąd "URI must contain a hostname": Upewnij się, że wywołujesz config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) przed utworzeniem ApiClient. Generator cpp-restsdk nie odczytuje automatycznie URL serwera z specyfikacji OpenAPI.
Błąd 401 "missing-api-key": Upewnij się, że wywołujesz config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) przed utworzeniem instancji DefaultAPI.
Nieprawidłowa klasa API: Użyj DefaultApi dla żądań uwierzytelnionych po stronie serwera, PublicApi dla żądań po stronie klienta/publicznych, oraz ModerationApi dla żądań panelu moderatora (uwierzytelnionych tokenem SSO moderatora).

Wywoływanie API: synchroniczne vs asynchroniczne

Wszystkie metody API w tym SDK zwracają pplx::task<std::shared_ptr<ResponseType>> z C++ REST SDK. Daje to elastyczność w tym, jak obsługujesz odpowiedzi API.

Wywołania synchroniczne przy użyciu `.get()`

Użyj .get(), aby zablokować wywołujący wątek aż żądanie zostanie zakończone i pobrać wynik synchronicznie:

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();  // Blokuje do momentu zakończenia żądania HTTP

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

Wywołania asynchroniczne przy użyciu `.then()`

Użyj .then(), aby wykonać nieblokujące asynchroniczne wywołanie z funkcjami zwrotnymi:

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) {
    // To zostaje wykonane asynchronicznie po zakończeniu żądania
    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;  // Wykonanie kontynuuje się natychmiast bez blokowania

Wybór pomiędzy synchronicznym a asynchronicznym

Wybór zależy od środowiska uruchomieniowego i architektury aplikacji:

.get() (Synchronous blocking)

Blokuje wywołujący wątek aż żądanie HTTP zostanie zakończone
Prostszy przepływ kodu, łatwiejszy do zrozumienia
Odpowiedni dla dedykowanych wątków roboczych, przetwarzania wsadowego lub narzędzi wiersza poleceń
Nieodpowiedni dla pętli zdarzeń, wątków GUI lub serwerów jednowątkowych

.then() (Asynchronous non-blocking)

Zwraca natychmiast, funkcja zwrotna jest wywoływana po zakończeniu żądania
Nie blokuje wywołującego wątku
Wymagany w architekturach zdarzeniowych, aplikacjach GUI lub jednowątkowych pętlach zdarzeń
Umożliwia łączenie wielu operacji
Bardziej złożony przepływ sterowania

Zestaw testów SDK używa wyłącznie .get(), ale jest to odpowiednie dla środowiska testowego, w którym blokowanie jest dopuszczalne.

Notatki

Identyfikatory Broadcast

Zauważysz, że w niektórych wywołaniach API trzeba przekazać broadcastId. Gdy otrzymasz zdarzenia, otrzymasz z powrotem ten identyfikator, dzięki czemu będziesz mógł zignorować zdarzenie, jeśli planujesz optymistycznie zastosować zmiany po stronie klienta (na co prawdopodobnie zechcesz się zdecydować, ponieważ zapewnia to najlepsze doświadczenie). Przekaż tutaj UUID. Identyfikator powinien być na tyle unikalny, aby nie wystąpił dwukrotnie w sesji przeglądarki.

SSO (logowanie jednokrotne)

Przykłady SSO znajdziesz poniżej.

Użycie SSO

Proste SSO

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

Bezpieczne SSO

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

Dokumentacja dla FastComments

Documentation for API Endpoints

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

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

Documentation for Models

Documentation for Authorization

api_key

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

Agregacja

Aggreguje dokumenty, grupując je (jeśli podano groupBy) i stosując wiele operacji. Obsługiwane są różne operacje (np. sum, countDistinct, avg itp.).

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
aggregationRequest	AggregationRequest	Tak
options	const AggregateOptions&	Tak

Odpowiedź

Zwraca: AggregateResponse

Przykład

Przykład agregacji

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();
            // przetwórz odpowiedź
        } catch (const std::exception& e) {
            // obsłuż błąd
        }
    });

pobierzLogiAudytu

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
options	const GetAuditLogsOptions&	Yes

Odpowiedź

Zwraca: GetAuditLogsResponse

Przykład

getAuditLogs Przykład

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();
        // użyj odpowiedzi
    } catch (const std::exception& e) {
        // obsłuż błąd
    }
});

wylogujPublicznie

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

Przykład logoutPublic

Copy

api->logoutPublic()
    .then([](std::shared_ptr<APIEmptyResponse> /*odpowiedź*/) {
        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;
        }
    });

zablokujZKomentarzaPublicznie

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentId	string	Tak
publicBlockFromCommentParams	PublicBlockFromCommentParams	Tak
sso	string	Nie

Odpowiedź

Zwraca: BlockSuccess

Przykład

blockFromCommentPublic Przykład

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

odblokujKomentarzPublicznie

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentId	string	Tak
publicBlockFromCommentParams	PublicBlockFromCommentParams	Tak
sso	string	Nie

Odpowiedź

Zwraca: UnblockSuccess

Przykład

unBlockCommentPublic Przykład

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

sprawdzoneKomentarzeDlaZablokowanych

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentIds	string	Tak
sso	string	Nie

Odpowiedź

Zwraca: CheckBlockedCommentsResponse

Przykład

checkedCommentsForBlocked Przykład

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

zablokujUżytkownikaZKomentarza

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
blockFromCommentParams	BlockFromCommentParams	Tak
options	const BlockUserFromCommentOptions&	Tak

Odpowiedź

Zwraca: BlockSuccess

Przykład

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

utwórzKomentarzPublicznie

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
urlId	string	Tak
broadcastId	string	Tak
commentData	CommentData	Tak
options	const CreateCommentPublicOptions&	Tak

Odpowiedź

Zwraca: SaveCommentsResponseWithPresence

Przykład

Przykład 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;
    });

usuńKomentarz

Parametry

Name	Type	Required
tenantId	string	Yes
id	string	Yes
options	const DeleteCommentOptions&	Yes

Odpowiedź

Zwraca: DeleteCommentResult

Przykład

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

usuńKomentarzPublicznie

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentId	string	Tak
broadcastId	string	Tak
options	const DeleteCommentPublicOptions&	Tak

Odpowiedź

Zwraca: PublicAPIDeleteCommentResponse

Przykład

deleteCommentPublic Przykład

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

usuńGłosKomentarza

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentId	string	Tak
voteId	string	Tak
urlId	string	Tak
broadcastId	string	Tak
options	const DeleteCommentVoteOptions&	Tak

Odpowiedź

Zwraca: VoteDeleteResponse

Przykład

Przykład 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;
    }
});

oznaczKomentarz

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
id	string	Yes
options	const FlagCommentOptions&	Yes

Odpowiedź

Zwraca: FlagCommentResponse

Przykład

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

pobierzKomentarz

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
id	string	Yes

Odpowiedź

Zwraca: APIGetCommentResponse

Przykład

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

pobierzKomentarze

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetCommentsOptions&	Tak

Odpowiedź

Zwraca: APIGetCommentsResponse

Przykład

Przykład 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();
        // użyj odpowiedzi w razie potrzeby
    } catch (const std::exception& e) {
        // obsłuż błąd
    }
});

pobierzKomentarzePublicznie

req tenantId urlId

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
urlId	string	Yes
options	const GetCommentsPublicOptions&	Yes

Odpowiedź

Returns: GetCommentsResponseWithPresence_PublicComment_

Przykład

Przykład 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;
});

pobierzTekstKomentarza

Parameters

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

Response

Zwraca: PublicAPIGetCommentTextResponse

Example

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

pobierzNazwyUżytkownikówGłosówKomentarza

Parameters

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentId	string	Tak
dir	int32_t	Tak
sso	string	Nie

Odpowiedź

Zwraca: GetCommentVoteUserNamesSuccessResponse

Przykład

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

zablokujKomentarz

Parameters

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

Response

Zwraca: APIEmptyResponse

Example

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

przypnijKomentarz

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Odpowiedź

Zwraca: ChangeCommentPinStatusResponse

Przykład

pinComment Przykład

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

zapiszKomentarz

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
createCommentParams	CreateCommentParams	Yes
options	const SaveCommentOptions&	Yes

Odpowiedź

Zwraca: APISaveCommentResponse

Przykład

Przykład 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;
    });

ustawTekstKomentarza

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
commentTextUpdateRequest	CommentTextUpdateRequest	Yes
options	const SetCommentTextOptions&	Yes

Odpowiedź

Zwraca: PublicAPISetCommentTextResponse

Przykład

setCommentText Przykład

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

odblokujUżytkownikaZKomentarza

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
id	string	Yes
unBlockFromCommentParams	UnBlockFromCommentParams	Yes
options	const UnBlockUserFromCommentOptions&	Yes

Odpowiedź

Zwraca: UnblockSuccess

Przykład

unBlockUserFromComment Przykład

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

odznaczKomentarz

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
id	string	Yes
options	const UnFlagCommentOptions&	Yes

Odpowiedź

Zwraca: FlagCommentResponse

Przykład

Przykład 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
        }
    });

odblokujKomentarz

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentId	string	Tak
broadcastId	string	Tak
sso	string	Nie

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

Przykład unLockComment

Copy

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

odpinKomentarz

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Odpowiedź

Zwraca: ChangeCommentPinStatusResponse

Przykład

Przykład 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);
});

zaktualizujKomentarz

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
updatableCommentParams	UpdatableCommentParams	Tak
options	const UpdateCommentOptions&	Tak

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

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

głosujZaKomentarzem

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
commentId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
voteBodyParams	VoteBodyParams	Yes
options	const VoteCommentOptions&	Yes

Odpowiedź

Zwraca: VoteResponse

Przykład

voteComment Przykład

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();
           // obsłuż odpowiedź
       } catch (const std::exception&) {
       }
   });

pobierzKomentarzeDlaUżytkownika

Parametry

Nazwa	Typ	Wymagane	Opis
options	const GetCommentsForUserOptions&	Tak

Odpowiedź

Zwraca: GetCommentsForUserResponse

Przykład

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

dodajKonfiguracjęDomeny

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
addDomainConfigParams	AddDomainConfigParams	Tak

Odpowiedź

Zwraca: AddDomainConfigResponse

Przykład

addDomainConfig Przykład

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

usuńKonfiguracjęDomeny

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
domain	string	Tak

Odpowiedź

Zwraca: DeleteDomainConfigResponse

Przykład

deleteDomainConfig Przykład

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

pobierzKonfiguracjęDomeny

Parameters

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
domain	string	Yes

Response

Zwraca: GetDomainConfigResponse

Przykład

Przykład 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) {
            // handle enabled moderation
        }
        if (theme) {
            // use theme value
        }
    })
    .wait();

pobierzKonfiguracjeDomen

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes

Odpowiedź

Zwraca: GetDomainConfigsResponse

Przykład

Przykład 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;
        }
    });

modyfikujKonfiguracjęDomeny

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
domainToUpdate	string	Yes
patchDomainConfigParams	PatchDomainConfigParams	Yes

Odpowiedź

Zwraca: PatchDomainConfigResponse

Przykład

Przykład 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) {
        // obsługa sukcesu
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* obsługa błędów */ }
    });

zapiszKonfiguracjęDomeny

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
domainToUpdate	string	Yes
updateDomainConfigParams	UpdateDomainConfigParams	Yes

Odpowiedź

Zwraca: PutDomainConfigResponse

Przykład

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

utwórzSzablonE‑mail

Parameters

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
createEmailTemplateBody	CreateEmailTemplateBody	Tak

Response

Zwraca: CreateEmailTemplateResponse

Przykład

Przykład 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;
    });

usuńSzablonE‑mail

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Zwraca: APIEmptyResponse

Example

deleteEmailTemplate Przykład

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

usuńBłądRenderowaniaSzablonuE‑mail

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
errorId	string	Tak

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

deleteEmailTemplateRenderError Przykład

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

pobierzSzablonE‑mail

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
id	string	Tak

Odpowiedź

Zwraca: GetEmailTemplateResponse

Przykład

getEmailTemplate Przykład

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

pobierzDefinicjeSzablonuE‑mail

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak

Odpowiedź

Zwraca: GetEmailTemplateDefinitionsResponse

Przykład

getEmailTemplateDefinitions Przykład

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

pobierzBłędyRenderowaniaSzablonuE‑mail

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
skip	double	Nie

Odpowiedź

Zwraca: GetEmailTemplateRenderErrorsResponse

Przykład

Przykład getEmailTemplateRenderErrors

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();
            // Użyj odpowiedzi w razie potrzeby
        } catch (const std::exception& ex) {
            // Obsłuż błąd
        }
    });

pobierzSzablonyE‑mail

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
skip	double	No

Odpowiedź

Zwraca: GetEmailTemplatesResponse

Przykład

Przykład 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;
    });

renderujSzablonE‑mail

Parameters

Nazwa	Typ	Wymagane
tenantId	string	Tak
renderEmailTemplateBody	RenderEmailTemplateBody	Tak
locale	string	Nie

Response

Zwraca: RenderEmailTemplateResponse

Example

renderEmailTemplate Przykład

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

zaktualizujSzablonE‑mail

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
id	string	Yes
updateEmailTemplateBody	UpdateEmailTemplateBody	Yes

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

updateEmailTemplate Przykład

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) {
        // obsługa sukcesu
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception &) { /* obsługa błędów */ }
    });

pobierzLogWydarzeń

req tenantId urlId userIdWS

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
urlId	string	Tak
userIdWS	string	Tak
startTime	int64_t	Tak
endTime	int64_t	Nie

Odpowiedź

Zwraca: GetEventLogResponse

Przykład

Przykład 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;
    });

pobierzGlobalnyLogWydarzeń

req tenantId urlId userIdWS

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
urlId	string	Tak
userIdWS	string	Tak
startTime	int64_t	Tak
endTime	int64_t	Nie

Odpowiedź

Zwraca: GetEventLogResponse

Przykład

Przykład getGlobalEventLog

Copy

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

utwórzPostNaKanale

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
createFeedPostParams	CreateFeedPostParams	Tak
options	const CreateFeedPostOptions&	Tak

Odpowiedź

Zwraca: CreateFeedPostsResponse

Przykład

createFeedPost Przykład

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

utwórzPostNaKanalePublicznie

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
createFeedPostParams	CreateFeedPostParams	Tak
options	const CreateFeedPostPublicOptions&	Tak

Odpowiedź

Zwraca: CreateFeedPostResponse

Przykład

Przykład 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;
        }
    });

usuńPostNaKanalePublicznie

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
postId	string	Tak
options	const DeleteFeedPostPublicOptions&	Tak

Odpowiedź

Zwraca: DeleteFeedPostPublicResponse

Przykład

Przykład 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()) {
            // success logic
        }
    });

pobierzPostyNaKanale

req tenantId afterId

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
options	const GetFeedPostsOptions&	Yes

Odpowiedź

Zwraca: GetFeedPostsResponse

Przykład

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

pobierzPostyNaKanalePublicznie

req tenantId afterId

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetFeedPostsPublicOptions&	Tak

Odpowiedź

Zwraca: PublicFeedPostsResponse

Przykład

getFeedPostsPublic Przykład

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);
        // Użyj przetworzonego w razie potrzeby
    }catch(const std::exception&){
        // Obsłuż błąd
    }
});

pobierzStatystykiPostówNaKanale

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
postIds	vector<string	Tak
sso	string	Nie

Odpowiedź

Zwraca: FeedPostsStatsResponse

Przykład

Przykład 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;
    });

pobierzReakcjeUżytkownikaPublicznie

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetUserReactsPublicOptions&	Tak

Odpowiedź

Zwraca: UserReactsResponse

Przykład

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

zareagujNaPostNaKanalePublicznie

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
postId	string	Tak
reactBodyParams	ReactBodyParams	Tak
options	const ReactFeedPostPublicOptions&	Tak

Odpowiedź

Zwraca: ReactFeedPostResponse

Przykład

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

zaktualizujPostNaKanale

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
feedPost	FeedPost	Tak

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

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

zaktualizujPostNaKanalePublicznie

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
postId	string	Yes
updateFeedPostParams	UpdateFeedPostParams	Yes
options	const UpdateFeedPostPublicOptions&	Yes

Odpowiedź

Zwraca: CreateFeedPostResponse

Przykład

updateFeedPostPublic Przykład

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

oznaczKomentarzPublicznie

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentId	string	Tak
isFlagged	bool	Tak
sso	string	Nie

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

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

pobierzDużyGif

Parameters

Name	Type	Required	Description
tenantId	string	Yes
largeInternalURLSanitized	string	Yes

Response

Zwraca: GifGetLargeResponse

Example

Przykład 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;
        }
   });

wyszukajGify

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
search	string	Yes
options	const GetGifsSearchOptions&	Yes

Odpowiedź

Zwraca: GetGifsSearchResponse

Przykład

getGifsSearch Przykład

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

pobierzPopularneGify

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetGifsTrendingOptions&	Tak

Odpowiedź

Zwraca: GetGifsTrendingResponse

Przykład

Przykład 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;
    }
});

dodajHashtag

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
createHashTagBody	CreateHashTagBody	Tak

Odpowiedź

Zwraca: CreateHashTagResponse

Przykład

addHashTag Przykład

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

dodajHashtagiMasowo

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Yes

Odpowiedź

Zwraca: BulkCreateHashTagsResponse

Przykład

Przykład addHashTagsBulk

Copy

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

usuńHashtag

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
tag	string	Tak
deleteHashTagRequestBody	DeleteHashTagRequestBody	Tak

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

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

pobierzHashtagi

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
page	double	Nie

Odpowiedź

Zwraca: GetHashTagsResponse

Przykład

Przykład 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);
        // użyj odpowiedzi
    } catch (const std::exception&) {
        // obsłuż błąd
    }
});

modyfikujHashtag

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
tag	string	Tak
updateHashTagBody	UpdateHashTagBody	Tak

Odpowiedź

Zwraca: UpdateHashTagResponse

Przykład

Przykład 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;
       }
   });

usuńGłosModeracji

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
commentId	string	Yes
voteId	string	Yes
options	const DeleteModerationVoteOptions&	Yes

Odpowiedź

Zwraca: VoteDeleteResponse

Przykład

deleteModerationVote Przykład

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

pobierzKomentarzeAPI

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetApiCommentsOptions&	Tak

Odpowiedź

Zwraca: ModerationAPIGetCommentsResponse

Przykład

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

pobierzStatusEksportuAPI

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetApiExportStatusOptions&	Tak

Odpowiedź

Zwraca: ModerationExportStatusResponse

Przykład

getApiExportStatus Przykład

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

pobierzIdAPI

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetApiIdsOptions&	Tak

Odpowiedź

Zwraca: ModerationAPIGetCommentIdsResponse

Przykład

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

pobierzZbanowanychUżytkownikówZKomentarza

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentId	string	Tak
sso	string	Nie

Odpowiedź

Zwraca: GetBannedUsersFromCommentResponse

Przykład

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

pobierzStatusBanaKomentarza

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentId	string	Tak
sso	string	Nie

Odpowiedź

Zwraca: GetCommentBanStatusResponse

Przykład

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

pobierzPodkomentarze

Parameters

Nazwa	Typ	Wymagane
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Response

Zwraca: ModerationAPIChildCommentsResponse

Example

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

pobierzLiczbę

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetCountOptions&	Tak

Odpowiedź

Zwraca: ModerationAPICountCommentsResponse

Przykład

Przykład getCount

Copy

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

pobierzLiczby

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
sso	string	Nie

Odpowiedź

Zwraca: GetBannedUsersCountResponse

Przykład

getCounts Przykład

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

pobierzLogi

Parameters

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentId	string	Tak
sso	string	Nie

Response

Zwraca: ModerationAPIGetLogsResponse

Example

getLogs Przykład

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

pobierzRęczneOdznaki

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
sso	string	Nie

Odpowiedź

Zwraca: GetTenantManualBadgesResponse

Przykład

Przykład 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();
            // przetwarzaj odpowiedź, np. response->badgeList
        } catch (const std::exception& ex) {
            // obsłuż błąd
        }
    });

pobierzRęczneOdznakiDlaUżytkownika

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetManualBadgesForUserOptions&	Tak

Odpowiedź

Zwraca: GetUserManualBadgesResponse

Przykład

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

pobierzKomentarzModeracji

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
commentId	string	Yes
options	const GetModerationCommentOptions&	Yes

Odpowiedź

Returns: ModerationAPICommentResponse

Przykład

Przykład 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();
            // Przetwórz odpowiedź w razie potrzeby
        } catch (const std::exception& ex) {
            // Obsłuż błąd
        }
    });

pobierzTekstKomentarzaModeracji

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Odpowiedź

Zwraca: GetCommentTextResponse

Przykład

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

pobierzPodsumowaniePrzedBanem

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentId	string	Tak
options	const GetPreBanSummaryOptions&	Tak

Odpowiedź

Zwraca: PreBanSummary

Przykład

Przykład 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();
            // przetwarzaj podsumowanie
        } catch (const std::exception&) {
            // obsłuż błąd
        }
    });

pobierzPodsumowanieWyszukiwaniaKomentarzy

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetSearchCommentsSummaryOptions&	Tak

Odpowiedź

Zwraca: ModerationCommentSearchResponse

Przykład

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

pobierzStronyWyszukiwania

Parametry

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

Odpowiedź

Zwraca: ModerationPageSearchResponse

Przykład

Przykład 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();
            // użyj odpowiedzi
        } catch (const std::exception& e) {
            // obsłuż błąd
        }
    });

pobierzStronyWyszukiwania

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetSearchSitesOptions&	Tak

Odpowiedź

Zwraca: ModerationSiteSearchResponse

Przykład

Przykład 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) {
               // logika przetwarzania
           }
       } catch (const std::exception&) {
           // obsługa błędów
       }
   });

pobierzSugestieWyszukiwania

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetSearchSuggestOptions&	Tak

Odpowiedź

Zwraca: ModerationSuggestResponse

Przykład

getSearchSuggest Przykład

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

pobierzUżytkownikówWyszukiwania

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetSearchUsersOptions&	Tak

Odpowiedź

Zwraca: ModerationUserSearchResponse

Przykład

getSearchUsers Przykład

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

pobierzWspółczynnikZaufania

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
options	const GetTrustFactorOptions&	Yes

Odpowiedź

Zwraca: GetUserTrustFactorResponse

Przykład

Przykład 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;
    }
});

pobierzPreferencjeBanaUżytkownika

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
sso	string	Nie

Odpowiedź

Zwraca: APIModerateGetUserBanPreferencesResponse

Przykład

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

pobierzWewnętrznyProfilUżytkownika

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
options	const GetUserInternalProfileOptions&	Yes

Odpowiedź

Zwraca: GetUserInternalProfileResponse

Przykład

getUserInternalProfile Przykład

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

wyślijDostosowanieGłosówKomentarza

Parameters

Nazwa	Typ	Wymagane
tenantId	string	Yes
commentId	string	Yes
adjustCommentVotesParams	AdjustCommentVotesParams	Yes
options	const PostAdjustCommentVotesOptions&	Yes

Response

Zwraca: AdjustVotesResponse

Example

postAdjustCommentVotes Przykład

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

wyślijEksportAPI

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
options	const PostApiExportOptions&	Yes

Odpowiedź

Zwraca: ModerationExportResponse

Przykład

postApiExport Przykład

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) {
            // obsłuż udaną odpowiedź eksportu
        }
    })
    .wait();

wyślijBanUżytkownikaZKomentarza

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentId	string	Tak
options	const PostBanUserFromCommentOptions&	Tak

Odpowiedź

Zwraca: BanUserFromCommentResult

Przykład

postBanUserFromComment Przykład

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) {
        // obsługa wyniku
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* obsługa błędów */ }
    });

wyślijCofnięcieBanaUżytkownika

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
banUserUndoParams	BanUserUndoParams	Yes
sso	string	No

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

postBanUserUndo Przykład

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){
    // obsłuż sukces
});

wyślijMasowePodsumowaniePrzedBanem

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
bulkPreBanParams	BulkPreBanParams	Yes
options	const PostBulkPreBanSummaryOptions&	Yes

Odpowiedź

Zwraca: BulkPreBanSummary

Przykład

postBulkPreBanSummary Przykład

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

wyślijKomentarzePoId

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentsByIdsParams	CommentsByIdsParams	Tak
sso	string	Nie

Odpowiedź

Zwraca: ModerationAPIChildCommentsResponse

Przykład

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

wyślijOznaczenieKomentarza

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
commentId	string	Yes
options	const PostFlagCommentOptions&	Yes

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

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

wyślijUsunięcieKomentarza

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
commentId	string	Yes
options	const PostRemoveCommentOptions&	Yes

Odpowiedź

Zwraca: PostRemoveCommentApiResponse

Przykład

postRemoveComment Przykład

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();
            // Przetwórz odpowiedź
        } catch (const std::exception& ex) {
            // Obsłuż błąd
        }
    });

wyślijPrzywrócenieUsuniętegoKomentarza

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentId	string	Tak
options	const PostRestoreDeletedCommentOptions&	Tak

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

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

wyślijUstawStatusZatwierdzeniaKomentarza

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentApprovalStatusOptions&	Yes

Odpowiedź

Zwraca: SetCommentApprovedResponse

Przykład

postSetCommentApprovalStatus Przykład

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

wyślijUstawStatusRecenzjiKomentarza

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentId	string	Tak
options	const PostSetCommentReviewStatusOptions&	Tak

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

postSetCommentReviewStatus Przykład

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

wyślijUstawStatusSpamuKomentarza

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentSpamStatusOptions&	Yes

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

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

wyślijUstawTekstKomentarza

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentId	string	Tak
setCommentTextParams	SetCommentTextParams	Tak
options	const PostSetCommentTextOptions&	Tak

Odpowiedź

Zwraca: SetCommentTextResponse

Przykład

postSetCommentText Przykład

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

wyślijCofnięcieOznaczeniaKomentarza

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
commentId	string	Tak
options	const PostUnFlagCommentOptions&	Tak

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

Przykład 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) {
        // przetwarzanie może być wykonane tutaj
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

wyślijGłos

Parametry

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

Odpowiedź

Zwraca: VoteResponse

Przykład

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

przyznajOdznakę

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
badgeId	string	Yes
options	const PutAwardBadgeOptions&	Yes

Odpowiedź

Zwraca: AwardUserBadgeResponse

Przykład

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

zamknijWątek

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
urlId	string	Tak
sso	string	Nie

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

Przykład putCloseThread

Copy

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

usuńOdznakę

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
badgeId	string	Yes
options	const PutRemoveBadgeOptions&	Yes

Odpowiedź

Zwraca: RemoveUserBadgeResponse

Przykład

Przykład 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;
});

otwórzPonownieWątek

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
urlId	string	Tak
sso	string	Nie

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

Przykład putReopenThread

Copy

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

ustawWspółczynnikZaufania

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const SetTrustFactorOptions&	Tak

Odpowiedź

Zwraca: SetUserTrustFactorResponse

Przykład

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

utwórzModeratora

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
createModeratorBody	CreateModeratorBody	Yes

Odpowiedź

Zwraca: CreateModeratorResponse

Przykład

createModerator Przykład

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

usuńModeratora

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
id	string	Yes
sendEmail	string	No

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

Przykład deleteModerator

Copy

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

pobierzModeratora

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
id	string	Tak

Odpowiedź

Zwraca: GetModeratorResponse

Przykład

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

pobierzModeratorów

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
skip	double	Nie

Odpowiedź

Zwraca: GetModeratorsResponse

Przykład

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

wyślijZaproszenie

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
fromName	string	Tak

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

Przykład 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) {
    // obsłuż pomyślne zaproszenie
});

zaktualizujModeratora

Parametry

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateModeratorBody	UpdateModeratorBody	Yes

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

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

usuńLiczbęPowiadomień

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
id	string	Tak

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

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

pobierzZbuforowanąLiczbęPowiadomień

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetCachedNotificationCountResponse

Example

getCachedNotificationCount Przykład

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();
            // process response
        } catch (const std::exception&) {
            // handle error
        }
    });

pobierzLiczbęPowiadomień

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetNotificationCountOptions&	Tak

Odpowiedź

Zwraca: GetNotificationCountResponse

Przykład

Przykład getNotificationCount

Copy

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

pobierzPowiadomienia

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetNotificationsOptions&	Tak

Odpowiedź

Zwraca: GetNotificationsResponse

Przykład

Przykład 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;
    });

zaktualizujPowiadomienie

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
updateNotificationBody	UpdateNotificationBody	Tak
userId	string	Nie

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

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

utwórzReakcjęStronyV1

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
urlId	string	Yes
title	string	No

Odpowiedź

Zwraca: CreateV1PageReact

Przykład

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

utwórzReakcjęStronyV2

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
urlId	string	Yes
id	string	Yes
title	string	No

Odpowiedź

Zwraca: CreateV1PageReact

Przykład

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

usuńReakcjęStronyV1

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
urlId	string	Yes

Odpowiedź

Zwraca: CreateV1PageReact

Przykład

deleteV1PageReact Przykład

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

usuńReakcjęStronyV2

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
urlId	string	Tak
id	string	Tak

Odpowiedź

Zwraca: CreateV1PageReact

Przykład

deleteV2PageReact Przykład

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

pobierzPolubieniaStronyV1

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
urlId	string	Tak

Odpowiedź

Zwraca: GetV1PageLikes

Przykład

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

pobierzReakcjeStronyV2

Parameters

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
urlId	string	Tak

Odpowiedź

Zwraca: GetV2PageReacts

Przykład

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

pobierzUżytkownikówReakcjiStronyV2

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
urlId	string	Tak
id	string	Tak

Odpowiedź

Zwraca: GetV2PageReactUsersResponse

Przykład

getV2PageReactUsers Przykład

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();
        // Użyj odpowiedzi w razie potrzeby
    }catch(const std::exception&){
        // Obsłuż błąd
    }
});

dodajStronę

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createAPIPageData	CreateAPIPageData	Yes

Response

Returns: AddPageAPIResponse

Example

Przykład 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) {
            // obsłuż pomyślne dodanie
        } else {
            // obsłuż błąd
        }
    });

usuńStronę

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
id	string	Tak

Odpowiedź

Zwraca: DeletePageAPIResponse

Przykład

deletePage Przykład

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();
           // przetwarzaj odpowiedź w razie potrzeby
       } catch (const std::exception& ex) {
           // obsłuż błąd
       }
   });

pobierzUżytkownikówOffline

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

Parameters

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

Response

Returns: PageUsersOfflineResponse

Example

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

pobierzUżytkownikówOnline

Obecnie online widzowie strony: osoby, których sesja websocket jest subskrybowana do tej strony w tej chwili.
Zwraca anonCount + totalCount (subskrybenci w całym pokoju, w tym anonimowi widzowie, których nie enumerujemy).

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
urlId	string	Tak
options	const GetOnlineUsersOptions&	Tak

Odpowiedź

Zwraca: PageUsersOnlineResponse

Przykład

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

pobierzStronęPoIdURL

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
urlId	string	Tak

Odpowiedź

Zwraca: GetPageByURLIdAPIResponse

Przykład

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

pobierzStrony

Parametry

Name	Type	Wymagane	Opis
tenantId	string	Tak

Odpowiedź

Zwraca: GetPagesAPIResponse

Przykład

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

pobierzStronyPublicznie

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

Parameters

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

Response

Returns: GetPublicPagesResponse

Example

Przykład 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();
        // process response if needed
    }catch(const std::exception&){
        // handle error if needed
    }
});

pobierzInfoUżytkowników

Bulk user info for a tenant. Given userIds, return display info from User / SSOUser.
Used by the comment widget to enrich users that just appeared via a presence event.
No page context: privacy is enforced uniformly (private profiles are masked).

Parameters

Name	Type	Required	Description
tenantId	string	Yes
ids	string	Yes

Response

Returns: PageUsersInfoResponse

Example

getUsersInfo Przykład

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

modyfikujStronę

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
updateAPIPageData	UpdateAPIPageData	Tak

Odpowiedź

Returns: PatchPageAPIResponse

Przykład

patchPage Przykład

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) {
            // obsłuż sukces
        }
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

usuńOczekująceZdarzenieWebhook

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
id	string	Yes

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

deletePendingWebhookEvent Przykład

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

pobierzLiczbęOczekującychZdarzeńWebhook

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetPendingWebhookEventCountOptions&	Tak

Odpowiedź

Zwraca: GetPendingWebhookEventCountResponse

Przykład

Przykład getPendingWebhookEventCount

Copy

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

pobierzOczekująceZdarzeniaWebhook

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
options	const GetPendingWebhookEventsOptions&	Yes

Odpowiedź

Zwraca: GetPendingWebhookEventsResponse

Przykład

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

utwórzKonfiguracjęPytania

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
createQuestionConfigBody	CreateQuestionConfigBody	Yes

Odpowiedź

Zwraca: CreateQuestionConfigResponse

Przykład

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

usuńKonfiguracjęPytania

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
id	string	Tak

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

deleteQuestionConfig Przykład

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) {
        // obsłuż pomyślne usunięcie
    })
    .then([](pplx::task<void> t) {
        try {
            t.get();
        } catch (const std::exception&) {
            // obsłuż błąd
        }
    });

pobierzKonfiguracjęPytania

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
id	string	Tak

Odpowiedź

Zwraca: GetQuestionConfigResponse

Przykład

Przykład 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();
            // Użyj odpowiedzi w razie potrzeby
        } catch (const std::exception&) {
            // Obsłuż błąd
        }
    });

pobierzKonfiguracjePytania

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
skip	double	No

Odpowiedź

Zwraca: GetQuestionConfigsResponse

Przykład

Przykład 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);
});

zaktualizujKonfiguracjęPytania

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
updateQuestionConfigBody	UpdateQuestionConfigBody	Tak

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

updateQuestionConfig Przykład

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

utwórzWynikPytania

Parametry

Name	Type	Required	Description
tenantId	string	Yes
createQuestionResultBody	CreateQuestionResultBody	Yes

Odpowiedź

Zwraca: CreateQuestionResultResponse

Przykład

createQuestionResult Przykład

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

usuńWynikPytania

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
id	string	Tak

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

Przykład 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();
                // obsługa sukcesu
            }
            catch ( const std::exception& e )
            {
                // obsługa błędu
            }
        } );
}

pobierzWynikPytania

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
id	string	Yes

Odpowiedź

Zwraca: GetQuestionResultResponse

Przykład

getQuestionResult Przykład

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

pobierzWynikiPytania

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetQuestionResultsOptions&	Tak

Odpowiedź

Zwraca: GetQuestionResultsResponse

Przykład

Przykład getQuestionResults

Copy

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

zaktualizujWynikPytania

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
id	string	Yes
updateQuestionResultBody	UpdateQuestionResultBody	Yes

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

updateQuestionResult Przykład

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

agregujWynikiPytania

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
options	const AggregateQuestionResultsOptions&	Yes

Odpowiedź

Zwraca: AggregateQuestionResultsResponse

Przykład

Przykład aggregateQuestionResults

Copy

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

masowaAgregacjaWynikówPytania

Parametry

Name	Type	Required
tenantId	string	Yes
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Yes
forceRecalculate	bool	No

Odpowiedź

Zwraca: BulkAggregateQuestionResultsResponse

Przykład

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

połączKomentarzeZWynikamiPytania

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const CombineCommentsWithQuestionResultsOptions&	Tak

Odpowiedź

Zwraca: CombineQuestionResultsWithCommentsResponse

Przykład

combineCommentsWithQuestionResults Przykład

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);
            // Użyj combined w razie potrzeby
        }catch(const std::exception&){
        }
    });

dodajUżytkownikaSSO

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
createAPISSOUserData	CreateAPISSOUserData	Tak

Odpowiedź

Zwraca: AddSSOUserAPIResponse

Przykład

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

usuńUżytkownikaSSO

Parameters

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
options	const DeleteSSOUserOptions&	Tak

Response

Zwraca: DeleteSSOUserAPIResponse

Example

Przykład deleteSSOUser

Copy

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

pobierzUżytkownikaSSOPoEmail

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
email	string	Tak

Odpowiedź

Zwraca: GetSSOUserByEmailAPIResponse

Przykład

getSSOUserByEmail Przykład

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

pobierzUżytkownikaSSOPoId

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
id	string	Tak

Odpowiedź

Returns: GetSSOUserByIdAPIResponse

Przykład

Przykład 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;
        }
    });

pobierzUżytkownikówSSO

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
skip	int32_t	Nie

Odpowiedź

Zwraca: GetSSOUsersResponse

Przykład

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

modyfikujUżytkownikaSSO

Parametry

Name	Type	Required
tenantId	string	Tak
id	string	Tak
updateAPISSOUserData	UpdateAPISSOUserData	Tak
updateComments	bool	Nie

Odpowiedź

Zwraca: PatchSSOUserAPIResponse

Przykład

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

zapiszUżytkownikaSSO

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
updateAPISSOUserData	UpdateAPISSOUserData	Tak
updateComments	bool	Nie

Odpowiedź

Zwraca: PutSSOUserAPIResponse

Przykład

putSSOUser Przykład

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

utwórzSubskrypcję

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Tak

Odpowiedź

Zwraca: CreateSubscriptionAPIResponse

Przykład

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

usuńSubskrypcję

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
id	string	Yes
userId	string	No

Odpowiedź

Zwraca: DeleteSubscriptionAPIResponse

Przykład

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

pobierzSubskrypcje

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
userId	string	Nie

Odpowiedź

Zwraca: GetSubscriptionsAPIResponse

Przykład

Przykład 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();
            // przetwarzaj odpowiedź
        } catch (const std::exception& e) {
            // obsłuż błąd
        }
    }
);

zaktualizujSubskrypcję

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
id	string	Yes
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	Yes
userId	string	No

Odpowiedź

Zwraca: UpdateSubscriptionAPIResponse

Przykład

Przykład updateSubscription

Copy

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

pobierzDziennyUżytekNajemcy

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetTenantDailyUsagesOptions&	Tak

Odpowiedź

Zwraca: GetTenantDailyUsagesResponse

Przykład

getTenantDailyUsages Przykład

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

utwórzPakietNajemcy

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
createTenantPackageBody	CreateTenantPackageBody	Yes

Odpowiedź

Returns: CreateTenantPackageResponse

Przykład

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

usuńPakietNajemcy

Parameters

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
id	string	Yes

Response

Returns: APIEmptyResponse

Example

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

pobierzPakietNajemcy

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
id	string	Yes

Odpowiedź

Zwraca: GetTenantPackageResponse

Przykład

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

pobierzPakietyNajemcy

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
skip	double	Nie

Odpowiedź

Zwraca: GetTenantPackagesResponse

Przykład

getTenantPackages Przykład

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

zastąpPakietNajemcy

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
id	string	Yes
replaceTenantPackageBody	ReplaceTenantPackageBody	Yes

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

replaceTenantPackage Przykład

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

zaktualizujPakietNajemcy

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
updateTenantPackageBody	UpdateTenantPackageBody	Tak

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

Przykład 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();
            // obsługa sukcesu
        } catch (const std::exception& ex) {
            // obsługa błędu
        }
    });

utwórzUżytkownikaNajemcy

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
createTenantUserBody	CreateTenantUserBody	Tak

Odpowiedź

Zwraca: CreateTenantUserResponse

Przykład

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

usuńUżytkownikaNajemcy

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
options	const DeleteTenantUserOptions&	Tak

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

deleteTenantUser Przykład

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

pobierzUżytkownikaNajemcy

Parameters

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
id	string	Tak

Response

Zwraca: GetTenantUserResponse

Example

Przykład 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();
            // Użyj odpowiedzi w razie potrzeby
        } catch (const std::exception&) {
            // Obsługa błędów
        }
    });

pobierzUżytkownikówNajemcy

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
skip	double	Nie

Odpowiedź

Returns: GetTenantUsersResponse

Przykład

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

zastąpUżytkownikaNajemcy

Parameters

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
replaceTenantUserBody	ReplaceTenantUserBody	Tak
updateComments	string	Nie

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

replaceTenantUser Przykład

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

wyślijLinkLogowania

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
redirectURL	string	Nie

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

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

zaktualizujUżytkownikaNajemcy

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
updateTenantUserBody	UpdateTenantUserBody	Tak
updateComments	string	Nie

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

updateTenantUser Przykład

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

utwórzNajemcę

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
createTenantBody	CreateTenantBody	Yes

Odpowiedź

Zwraca: CreateTenantResponse

Przykład

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

usuńNajemcę

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
sure	string	Nie

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

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

pobierzNajemcę

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
id	string	Tak

Odpowiedź

Zwraca: GetTenantResponse

Przykład

Przykład 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;
        }
    });

pobierzNajemców

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetTenantsOptions&	Tak

Odpowiedź

Zwraca: GetTenantsResponse

Przykład

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

zaktualizujNajemcę

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
id	string	Yes
updateTenantBody	UpdateTenantBody	Yes

Odpowiedź

Zwraca: APIEmptyResponse

Przykład

Przykład 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;
});

zmieńStanZgłoszenia

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
userId	string	Tak
id	string	Tak
changeTicketStateBody	ChangeTicketStateBody	Tak

Odpowiedź

Zwraca: ChangeTicketStateResponse

Przykład

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

utwórzZgłoszenie

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
userId	string	Tak
createTicketBody	CreateTicketBody	Tak

Odpowiedź

Zwraca: CreateTicketResponse

Przykład

Przykład 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();
        // Użyj odpowiedzi w razie potrzeby
    }catch(const std::exception&){
        // Obsłuż błąd
    }
});

pobierzZgłoszenie

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
userId	string	Nie

Odpowiedź

Zwraca: GetTicketResponse

Przykład

getTicket Przykład

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

pobierzZgłoszenia

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const GetTicketsOptions&	Tak

Odpowiedź

Zwraca: GetTicketsResponse

Przykład

Przykład getTickets

Copy

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

pobierzTłumaczenia

Parametry

Nazwa	Typ	Wymagane
r_namespace	string	Tak
component	string	Tak
options	const GetTranslationsOptions&	Tak

Odpowiedź

Zwraca: GetTranslationsResponse

Przykład

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

prześlijObraz

Upload and resize an image

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
file	HttpContent	Tak
options	const UploadImageOptions&	Tak

Odpowiedź

Zwraca: UploadImageResponse

Przykład

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

pobierzPostępOdznakiUżytkownikaPoId

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
id	string	Tak

Odpowiedź

Zwraca: APIGetUserBadgeProgressResponse

Przykład

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

pobierzPostępOdznakiUżytkownikaPoIdUżytkownika

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
userId	string	Yes

Odpowiedź

Zwraca: APIGetUserBadgeProgressResponse

Przykład

Przykład 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;
        }
    });

pobierzListęPostępuOdznakUżytkownika

Parametry

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

Odpowiedź

Zwraca: APIGetUserBadgeProgressListResponse

Przykład

Przykład 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) {
            // przetwarzaj odznakę
        }
    });

utwórzOdznakęUżytkownika

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
createUserBadgeParams	CreateUserBadgeParams	Yes

Odpowiedź

Zwraca: APICreateUserBadgeResponse

Przykład

createUserBadge Przykład

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

usuńOdznakęUżytkownika

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
id	string	Tak

Odpowiedź

Zwraca: APIEmptySuccessResponse

Przykład

deleteUserBadge Przykład

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

pobierzOdznakęUżytkownika

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
id	string	Tak

Odpowiedź

Zwraca: APIGetUserBadgeResponse

Przykład

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

pobierzOdznakiUżytkownika

Parameters

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

Response

Zwraca: APIGetUserBadgesResponse

Example

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

zaktualizujOdznakęUżytkownika

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
id	string	Tak
updateUserBadgeParams	UpdateUserBadgeParams	Tak

Odpowiedź

Zwraca: APIEmptySuccessResponse

Przykład

Przykład updateUserBadge

Copy

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

pobierzLiczbęPowiadomieńUżytkownika

Parametry

Name	Type	Required	Description
tenantId	string	Tak
sso	string	Nie

Odpowiedź

Zwraca: GetUserNotificationCountResponse

Przykład

getUserNotificationCount Przykład

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("user@example.com");
api->getUserNotificationCount(tenantId, sso).then([](pplx::task<std::shared_ptr<GetUserNotificationCountResponse>> t){
    try{
        auto resp = t.get();
        // użyj resp w razie potrzeby
    }catch(const std::exception&){
        // obsłuż błąd
    }
});

pobierzPowiadomieniaUżytkownika

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
options	const GetUserNotificationsOptions&	Yes

Odpowiedź

Zwraca: GetMyNotificationsResponse

Przykład

getUserNotifications Przykład

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

zresetujLiczbęPowiadomieńUżytkownika

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Yes
sso	string	No

Odpowiedź

Zwraca: ResetUserNotificationsResponse

Przykład

resetUserNotificationCount Przykład

Copy

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

zresetujPowiadomieniaUżytkownika

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
options	const ResetUserNotificationsOptions&	Tak

Odpowiedź

Zwraca: ResetUserNotificationsResponse

Przykład

resetUserNotifications Przykład

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) {
        // Przetwórz odpowiedź
    });

zaktualizujStatusSubskrypcjiPowiadomieńKomentarzyUżytkownika

Enable or disable notifications for a specific comment.

Parameters

Name	Type	Required
tenantId	string	Yes
notificationId	string	Yes
optedInOrOut	string	Yes
commentId	string	Yes
sso	string	No

Response

Zwraca: UpdateUserNotificationCommentSubscriptionStatusResponse

Przykład

Przykład updateUserNotificationCommentSubscriptionStatus

Copy

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

zaktualizujStatusSubskrypcjiPowiadomieńStronUżytkownika

Enable lub wyłącz powiadomienia dla strony. Gdy użytkownicy są subskrybowani do strony, tworzone są powiadomienia dla nowych głównych komentarzy oraz również

Parameters

Nazwa	Typ	Wymagane
tenantId	string	Tak
urlId	string	Tak
url	string	Tak
pageTitle	string	Tak
subscribedOrUnsubscribed	string	Tak
sso	string	Nie

Response

Zwraca: UpdateUserNotificationPageSubscriptionStatusResponse

Example

updateUserNotificationPageSubscriptionStatus Przykład

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) {
        // przetwórz odpowiedź w razie potrzeby
    });

zaktualizujStatusPowiadomieńUżytkownika

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Tak
notificationId	string	Tak
newStatus	string	Tak
sso	string	Nie

Odpowiedź

Zwraca: UpdateUserNotificationStatusResponse

Przykład

Przykład 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();

pobierzStatusyObecnościUżytkownika

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
urlIdWS	string	Yes
userIds	string	Yes

Odpowiedź

Zwraca: GetUserPresenceStatusesResponse

Przykład

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

szukajUżytkowników

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
urlId	string	Yes
options	const SearchUsersOptions&	Yes

Odpowiedź

Zwraca: SearchUsersResult

Przykład

searchUsers Przykład

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

pobierzUżytkownika

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
id	string	Tak

Odpowiedź

Zwraca: GetUserResponse

Przykład

getUser Przykład

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>();
            }
            // przetwarzaj odpowiedź w razie potrzeby
        } catch (const std::exception&) {
            // obsłuż błąd
        }
    });

utwórzGłos

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
commentId	string	Yes
direction	string	Yes
options	const CreateVoteOptions&	Yes

Odpowiedź

Zwraca: VoteResponse

Przykład

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

usuńGłos

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
id	string	Yes
editKey	string	No

Odpowiedź

Zwraca: VoteDeleteResponse

Przykład

Przykład 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();
        // Przetwórz odpowiedź w razie potrzeby
    } catch (const std::exception&) {
        // Obsłuż błąd
    }
});

pobierzGłosy

Parametry

Nazwa	Typ	Wymagane	Opis
tenantId	string	Tak
urlId	string	Tak

Odpowiedź

Zwraca: GetVotesResponse

Przykład

Przykład 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 (...) {
        // obsługa błędów
    }
});

pobierzGłosyDlaUżytkownika

Parametry

Nazwa	Typ	Wymagane
tenantId	string	Yes
urlId	string	Yes
options	const GetVotesForUserOptions&	Yes

Odpowiedź

Zwraca: GetVotesForUserResponse

Przykład

Przykład 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) {
        // obsłuż odpowiedź, np. iteruj głosy
    }
});

Potrzebujesz pomocy?

Jeśli napotkasz jakiekolwiek problemy lub masz pytania dotyczące C++ SDK, prosimy:

Współtworzenie

Wkłady są mile widziane! Odwiedź repozytorium GitHub, aby zapoznać się z wytycznymi dotyczącymi wkładu.

Język 🇵🇱 Polski

Dokumentacja

Rozpoczęcie

Referencja API

Użycie

Agregacja

Logi audytu

Uwierzytelnianie

Blokowanie z komentarza

Sprawdź zablokowane komentarze

Komentarze

Komentarze dla użytkownika

Konfiguracje domen

Szablony e‑mail

Log wydarzeń

Posty w kanale

Oznacz komentarz

Gify

Hashtagi

Moderacja

Moderatorzy

Liczba powiadomień

Powiadomienia

Reakcje na stronie

Strony

Oczekujące zdarzenia webhook

Konfiguracje pytań

Wyniki pytań

Agregacja wyników pytań

Użytkownicy SSO

Subskrypcje

Dzienny użytek najemcy

Pakiety najemcy

Użytkownicy najemcy

Najemcy

Zgłoszenia

Tłumaczenia

Przesyłanie obrazu

Postęp odznak użytkownika

Odznaki użytkownika

Powiadomienia użytkownika

Statusy obecności użytkownika

Wyszukiwanie użytkowników

Użytkownicy

Głosy

FastComments C++ SDK

Repozytorium

Agenci kodowania AI

Wymagania

Instalacja

Instalacja zależności

Budowanie ze źródła

Instalacja

Zawartość biblioteki

Publiczne vs Zabezpieczone API

Szybki start

Using Authenticated APIs (DefaultAPI)

Using Public APIs (PublicAPI)

Using Moderation APIs (ModerationApi)

Common Issues

Wywoływanie API: synchroniczne vs asynchroniczne

Wywołania synchroniczne przy użyciu .get()

Wywołania asynchroniczne przy użyciu .then()

Wybór pomiędzy synchronicznym a asynchronicznym

Notatki

Identyfikatory Broadcast

SSO (logowanie jednokrotne)

Użycie SSO

Proste SSO

Bezpieczne SSO

Dokumentacja dla FastComments

Documentation for API Endpoints

Documentation for Models

Documentation for Authorization

api_key

Agregacja

Parametry

Odpowiedź

Przykład

pobierzLogiAudytu

Wywołania synchroniczne przy użyciu `.get()`

Wywołania asynchroniczne przy użyciu `.then()`