FastComments C++ SDK

Oto oficjalne SDK C++ dla FastComments.

Oficjalne SDK C++ dla API FastComments

Repozytorium

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

Uwagi

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.

Korzystanie z 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 FastComments

Dokumentacja punktów końcowych API

Wszystkie URI są względne do https://fastcomments.com

Klasa	Metoda	Żądanie HTTP	Opis
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	Agreguje dokumenty przez grupowanie ich (jeśli podano `groupBy`) i stosowanie wielu operacji. Wspierane są różne operacje (np. sum, countDistinct, avg itp.).
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	Poprzedni komentujący na stronie, którzy NIE są aktualnie online. Posortowani według `displayName`. Użyj tego po wyczerpaniu `/users/online`, aby wyświetlić sekcję „Members”. Stronicowanie kursorem po `commenterName`: serwer przechodzi po częściowym indeksie `{tenantId, urlId, commenterName}` od `afterName` do przodu przy użyciu `$gt`, bez kosztu `$skip`.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	Obecnie online oglądający stronę: osoby, które mają aktywną sesję websocket subskrybowaną do tej strony. Zwraca `anonCount` + `totalCount` (całkowita liczba subskrybentów pokoju, włącznie z anonimowymi widzami, których nie wyliczamy).
PublicApi	getPagesPublic	GET /pages/{tenantId}	Lista stron dla najemcy. Używana przez klienta desktopowego FChat do wypełniania listy pokoi. Wymaga, aby `enableFChat` było ustawione na `true` w rozwiązywanej konfiguracji niestandardowej każdej strony. Strony wymagające SSO są filtrowane w oparciu o dostęp grupowy żądającego użytkownika.
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	Masowa informacja o użytkownikach dla najemcy. Na podstawie `userIds` zwraca informacje wyświetlane z `User`/`SSOUser`. Używane przez widget komentarzy do wzbogacania użytkowników, którzy właśnie pojawili się poprzez zdarzenie obecności. Brak kontekstu strony: prywatność jest egzekwowana jednolicie (prywatne profile są maskowane).
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}	Włącz lub wyłącz powiadomienia dla konkretnego komentarza.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Włącz lub wyłącz powiadomienia dla strony. Gdy użytkownicy są subskrybowani do strony, tworzono powiadomienia o nowych komentarzach głównych oraz
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Prześlij i zmień rozmiar obrazu
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Dokumentacja modeli

aggregate

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

getAuditLogs

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

logoutPublic

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

blockFromCommentPublic

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

unBlockCommentPublic

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

checkedCommentsForBlocked

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

blockUserFromComment

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

createCommentPublic

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

deleteComment

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

deleteCommentPublic

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

deleteCommentVote

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

flagComment

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

getComment

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

getComments

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

getCommentsPublic

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

getCommentText

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

getCommentVoteUserNames

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

lockComment

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

pinComment

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

saveComment

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

setCommentText

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

unBlockUserFromComment

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

unFlagComment

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

unLockComment

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

unPinComment

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

updateComment

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

voteComment

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

getCommentsForUser

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

addDomainConfig

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

deleteDomainConfig

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

getDomainConfig

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

getDomainConfigs

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

patchDomainConfig

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

putDomainConfig

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

createEmailTemplate

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

deleteEmailTemplate

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

deleteEmailTemplateRenderError

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

getEmailTemplate

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

getEmailTemplateDefinitions

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

getEmailTemplateRenderErrors

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

getEmailTemplates

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

renderEmailTemplate

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

updateEmailTemplate

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

getEventLog

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

getGlobalEventLog

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

createFeedPost

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

createFeedPostPublic

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

deleteFeedPostPublic

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

getFeedPosts

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

getFeedPostsPublic

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

getFeedPostsStats

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

getUserReactsPublic

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

reactFeedPostPublic

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

updateFeedPost

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

updateFeedPostPublic

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

flagCommentPublic

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

getGifLarge

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

getGifsSearch

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

getGifsTrending

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

addHashTag

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

addHashTagsBulk

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

deleteHashTag

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

getHashTags

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

patchHashTag

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

deleteModerationVote

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

getApiComments

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

getApiExportStatus

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

getApiIds

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

getBanUsersFromComment

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

getCommentBanStatus

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

getCommentChildren

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

getCount

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

getCounts

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

getLogs

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

getManualBadges

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

getManualBadgesForUser

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

getModerationComment

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

getModerationCommentText

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

getPreBanSummary

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

getSearchCommentsSummary

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

getSearchPages

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

getSearchSites

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

getSearchSuggest

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

getSearchUsers

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

getTrustFactor

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

getUserBanPreference

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

getUserInternalProfile

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

postAdjustCommentVotes

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

postApiExport

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

postBanUserFromComment

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

postBanUserUndo

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

postBulkPreBanSummary

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

postCommentsByIds

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

postFlagComment

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

postRemoveComment

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

postRestoreDeletedComment

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

postSetCommentApprovalStatus

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

postSetCommentReviewStatus

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

postSetCommentSpamStatus

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

postSetCommentText

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

postUnFlagComment

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

postVote

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

putAwardBadge

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

putCloseThread

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

putRemoveBadge

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

putReopenThread

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

setTrustFactor

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

createModerator

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

deleteModerator

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

getModerator

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

getModerators

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

sendInvite

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

updateModerator

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

deleteNotificationCount

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

getCachedNotificationCount

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

getNotificationCount

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

getNotifications

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

updateNotification

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

createV1PageReact

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

createV2PageReact

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

deleteV1PageReact

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

deleteV2PageReact

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

getV1PageLikes

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

getV2PageReacts

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

getV2PageReactUsers

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

addPage

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

deletePage

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

getOfflineUsers

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

getOnlineUsers

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

getPageByURLId

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

getPages

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

getPagesPublic

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

Parameters

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

getUsersInfo

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

patchPage

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

deletePendingWebhookEvent

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

getPendingWebhookEventCount

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

getPendingWebhookEvents

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

createQuestionConfig

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

deleteQuestionConfig

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

getQuestionConfig

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

getQuestionConfigs

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

updateQuestionConfig

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

createQuestionResult

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

deleteQuestionResult

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

getQuestionResult

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

getQuestionResults

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

updateQuestionResult

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

aggregateQuestionResults

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

bulkAggregateQuestionResults

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

combineCommentsWithQuestionResults

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

addSSOUser

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

deleteSSOUser

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

getSSOUserByEmail

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

getSSOUserById

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

getSSOUsers

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

patchSSOUser

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

putSSOUser

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

createSubscription

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

deleteSubscription

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

getSubscriptions

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

updateSubscription

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

getTenantDailyUsages

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

createTenantPackage

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

deleteTenantPackage

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

getTenantPackage

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

getTenantPackages

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

replaceTenantPackage

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

updateTenantPackage

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

createTenantUser

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

deleteTenantUser

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

getTenantUser

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

getTenantUsers

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

replaceTenantUser

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

sendLoginLink

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

updateTenantUser

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

createTenant

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

deleteTenant

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

getTenant

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

getTenants

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

updateTenant

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

changeTicketState

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

createTicket

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

getTicket

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

getTickets

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

getTranslations

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

uploadImage

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

getUserBadgeProgressById

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

getUserBadgeProgressByUserId

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

getUserBadgeProgressList

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

createUserBadge

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

deleteUserBadge

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

getUserBadge

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

getUserBadges

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

updateUserBadge

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

getUserNotificationCount

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

getUserNotifications

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

resetUserNotificationCount

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

resetUserNotifications

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

updateUserNotificationCommentSubscriptionStatus

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

updateUserNotificationPageSubscriptionStatus

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

updateUserNotificationStatus

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

getUserPresenceStatuses

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

searchUsers

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

getUser

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

createVote

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

deleteVote

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

getVotes

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

getVotesForUser

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

Pierwsze kroki

Referencja API

Użycie

Agregacja

Dzienniki audytu

Uwierzytelnianie

Blokowanie z komentarza

Sprawdź zablokowane komentarze

Komentarze

Komentarze użytkownika

Konfiguracje domeny

Szablony e-mail

Dziennik zdarzeń

Posty

Zgłaszanie komentarza

Gify

Hashtagi

Moderacja

Moderatorzy

Liczba powiadomień

Powiadomienia

Reakcje strony

Strony

Oczekujące zdarzenia webhook

Konfiguracje pytań

Wyniki pytań

Agregacja wyników pytań

Użytkownicy SSO

Subskrypcje

Dzienne użycie najemcy

Pakiety najemcy

Użytkownicy najemcy

Najemcy

Zgłoszenia

Tłumaczenia

Prześlij obraz

Postęp odznaki użytkownika

Odznaki użytkownika

Powiadomienia użytkownika

Status obecności użytkownika

Wyszukiwanie użytkowników

Użytkownicy

Głosy

FastComments C++ SDK

Repozytorium

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 i asynchroniczne

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

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

Wybór pomiędzy synchronicznym a asynchronicznym

Uwagi

Identyfikatory Broadcast

SSO (logowanie jednokrotne)

Korzystanie z SSO

Proste SSO

Bezpieczne SSO

Dokumentacja FastComments

Dokumentacja punktów końcowych API

Dokumentacja modeli

aggregate

Parametry

Odpowiedź

Przykład

getAuditLogs

Parametry

Odpowiedź

Przykład

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

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