FastComments C++ SDK

Ovo je zvanični C++ SDK za FastComments.

Zvanični C++ SDK za FastComments API

Repozitorijum

Zahtevi

C++17 ili noviji
CMake 3.14 ili noviji
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (automatski preuzet za testiranje)

Instalacija

Instalacija zavisnosti

sudo apt install libcpprest-dev libboost-all-dev

Izgradnja iz izvornog koda

mkdir build
cd build
cmake ..
make

Instalacija

sudo make install

Sadržaj biblioteke

Ova biblioteka sadrži generisani API klijent i SSO alate koji olakšavaju rad sa API‑jem.

API Client Library Docs

Javni vs zaštićeni API‑ji

Za API klijent postoje tri klase, DefaultApi, PublicApi i ModerationApi. DefaultApi sadrži metode koje zahtevaju vaš API ključ, a PublicApi sadrži metode koje se mogu pozvati direktno iz pregledača/mobilnog uređaja/ipd. bez autentifikacije. ModerationApi pruža opsežan skup API‑ja za brzu i trenutnu moderaciju. Svaka metoda ModerationApi prihvata sso parametar i može se autentifikovati putem SSO‑a ili sesijskog kolačića na FastComments.com.

Brzi početak

Korišćenje autentifikovanih API-ja (DefaultAPI)

Važno:

Morate postaviti osnovni URL (cpp-restsdk generator ga ne čita iz OpenAPI specifikacije)
Morate postaviti svoj API ključ na ApiClient pre nego što napravite autentifikovane zahteve. Ako to ne uradite, zahtevi će propasti sa greškom 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>();

    // OBLIGATNO: Postavite osnovni URL (odaberite vašu regiju)
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));  // SAD
    // ILI: config->setBaseUrl(utility::conversions::to_string_t("https://eu.fastcomments.com"));  // EU

    // OBLIGATNO: Postavite svoj API ključ
    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);

    // Sada napravite autentifikovane API pozive
    return 0;
}

Korišćenje javnih API-ja (PublicAPI)

Javni krajnji ostvarivači ne zahtevaju autentifikaciju:

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

    // OBLIGATNO: Postavite osnovni 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);

    // Napravite javne API pozive
    return 0;
}

Korišćenje Moderacionih API-ja (ModerationApi)

ModerationApi pokreće moderatorsku kontrolnu tablu. Svaki metod prihvata sso parametar tako da se poziv izvršava u ime moderatora autentifikovanog putem SSO (pogledajte SSO sekciju ispod za način kreiranja tokena):

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

    // OBLIGATNO: Postavite osnovni 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);

    // Prosledite SSO token moderatora da autentifikujete poziv
    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;
}

Uobičajeni problemi

Greška "URI must contain a hostname": Proverite da pozovete config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) pre kreiranja ApiClient‑a. cpp-restsdk generator ne čita automatski URL servera iz OpenAPI specifikacije.
Greška 401 "missing-api-key": Proverite da pozovete config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) pre kreiranja DefaultAPI instance.
Pogrešna API klasa: Koristite DefaultApi za server‑side autentifikovane zahteve, PublicApi za klijentske/javne zahteve, i ModerationApi za zahteve moderatorske kontrolne table (autentifikovane SSO tokenom moderatora).

Pozivi ka API-ju: sinhrono vs asinhrono

Sve API metode u ovom SDK‑u vraćaju pplx::task<std::shared_ptr<ResponseType>> iz C++ REST SDK‑a. Ovo vam pruža fleksibilnost u načinu na koji obrađujete API odgovore.

Sinhroni pozivi sa `.get()`

Koristite .get() da blokirate nit koja poziva dok se zahtev ne završi i da sinhrono dobijete rezultat:

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

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

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

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

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

Asinkroni pozivi sa `.then()`

Koristite .then() za neblokirajuću asinkronu izvršavanje sa povratnim pozivima (callback-ovima):

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

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

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

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

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

Izbor između sinhronog i asinkronog

Izbor zavisi od vašeg runtime okruženja i arhitekture aplikacije:

.get() (Sinhrono blokiranje)

Blokira nit koja poziva dok HTTP zahtev ne bude završen
Jednostavniji tok koda, lakše je razumeti
Pogodno za posvećene radne niti, obradu u batch režimu ili komandno‑linijske alate
Nije pogodno za petlje događaja, GUI niti ili jednonitne servere

.then() (Asinkrono neblokirajuće)

Vraća se odmah, povratni poziv se izvršava kada zahtev bude završen
Ne blokira nit koja poziva
Potrebno za arhitekture bazirane na događajima, GUI aplikacije ili jednonitne petlje događaja
Omogućava lančanje više operacija
Kompleksniji tok kontrole

Testni skup SDK‑a koristi isključivo .get(), ali to je odgovarajuće za testno okruženje gde je blokiranje prihvatljivo.

Beleške

Broadcast ID-jevi

Videćete da treba da prosledite broadcastId u nekim API pozivima. Kada primite događaje, dobićete ovaj ID nazad, tako da znate da ignorišete događaj ako planirate da optimistično primenite promene na klijentu (što verovatno želite da uradite jer pruža najbolje iskustvo). Ovde prosledite UUID. ID bi trebalo da bude dovoljno jedinstven da se ne pojavi dva puta u jednoj sesiji pregledača.

SSO (Jedinstvena prijava)

Za SSO primere, pogledajte ispod.

Korišćenje SSO

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

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

Dokumentacija za FastComments

Dokumentacija za API krajnje tačke

Svi URI‑i su relativni u odnosu na https://fastcomments.com

Class	Method	HTTP request	Description
DefaultApi	addDomainConfig	POST /api/v1/domain-configs
DefaultApi	addHashTag	POST /api/v1/hash-tags
DefaultApi	addHashTagsBulk	POST /api/v1/hash-tags/bulk
DefaultApi	addPage	POST /api/v1/pages
DefaultApi	addSSOUser	POST /api/v1/sso-users
DefaultApi	aggregate	POST /api/v1/aggregate	Agregira dokumente grupisanjem (ako je naveden parametar groupBy) i primenom više operacija. Podržane su različite operacije (npr. sum, countDistinct, avg, itd.).
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	Prethodni komentatori na stranici koji NISU trenutno online. Sortirano po displayName. Koristite ovo nakon što iscrpite /users/online da biste prikazali odeljak "Members". Kursorska paginacija po commenterName: server prolazi kroz parcijalni indeks {tenantId, urlId, commenterName} od afterName napred putem $gt, bez $skip troška.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	Trenutno online posetioci stranice: osobe čija je websocket sesija pretplaćena na stranicu u ovom momentu. Vraća anonCount + totalCount (pretplatnici na celu sobu, uključujući anonimne posetioce koje ne izlistavamo).
PublicApi	getPagesPublic	GET /pages/{tenantId}	Lista stranica za tenant. Koristi FChat desktop klijent da popuni listu soba. Zahteva da `enableFChat` bude true u razrešenom prilagođenom konfiguraciji za svaku stranicu. Stranice koje zahtevaju SSO filtriraju se prema grupnom pristupu korisnika koji zahteva.
PublicApi	getTranslations	GET /translations/{namespace}/{component}
PublicApi	getUserNotificationCount	GET /user-notifications/get-count
PublicApi	getUserNotifications	GET /user-notifications
PublicApi	getUserPresenceStatuses	GET /user-presence-status
PublicApi	getUserReactsPublic	GET /feed-posts/{tenantId}/user-reacts
PublicApi	getUsersInfo	GET /pages/{tenantId}/users/info	Bulk user info for a tenant. Given userIds, return display info from User / SSOUser. Used by the comment widget to enrich users that just appeared via a presence event. No page context: privacy is enforced uniformly (private profiles are masked).
PublicApi	getV1PageLikes	GET /page-reacts/v1/likes/{tenantId}
PublicApi	getV2PageReactUsers	GET /page-reacts/v2/{tenantId}/list
PublicApi	getV2PageReacts	GET /page-reacts/v2/{tenantId}
PublicApi	lockComment	POST /comments/{tenantId}/{commentId}/lock
PublicApi	logoutPublic	PUT /auth/logout
PublicApi	pinComment	POST /comments/{tenantId}/{commentId}/pin
PublicApi	reactFeedPostPublic	POST /feed-posts/{tenantId}/react/{postId}
PublicApi	resetUserNotificationCount	POST /user-notifications/reset-count
PublicApi	resetUserNotifications	POST /user-notifications/reset
PublicApi	searchUsers	GET /user-search/{tenantId}
PublicApi	setCommentText	POST /comments/{tenantId}/{commentId}/update-text
PublicApi	unBlockCommentPublic	DELETE /block-from-comment/{commentId}
PublicApi	unLockComment	POST /comments/{tenantId}/{commentId}/unlock
PublicApi	unPinComment	POST /comments/{tenantId}/{commentId}/unpin
PublicApi	updateFeedPostPublic	PUT /feed-posts/{tenantId}/{postId}
PublicApi	updateUserNotificationCommentSubscriptionStatus	POST /user-notifications/{notificationId}/mark-opted/{optedInOrOut}	Omogući ili onemogući obaveštenja za određeni komentar.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Omogući ili onemogući obaveštenja za stranicu. Kada su korisnici pretplaćeni na stranicu, obaveštenja se kreiraju za nove korenske komentare, i takođe
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Upload and resize an image
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Dokumentacija za modele

aggregate

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

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
aggregationRequest	AggregationRequest	Yes
options	const AggregateOptions&	Yes

Odgovor

Returns: AggregateResponse

Primer

aggregate Primer

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();
            // obradi odgovor
        } catch (const std::exception& e) {
            // rukovanje greškom
        }
    });

getAuditLogs

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetAuditLogsOptions&	Da

Odgovor

Vraća: GetAuditLogsResponse

Primer

Primer getAuditLogs

Copy

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

logoutPublic

Odgovor

Vraća: APIEmptyResponse

Primer

logoutPublic Primer

Copy

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

blockFromCommentPublic

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
publicBlockFromCommentParams	PublicBlockFromCommentParams	Yes
sso	string	No

Odgovor

Vraća: BlockSuccess

Primer

blockFromCommentPublic Primer

Copy

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

unBlockCommentPublic

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
commentId	string	Da
publicBlockFromCommentParams	PublicBlockFromCommentParams	Da
sso	string	Ne

Odgovor

Vraća: UnblockSuccess

Primer

unBlockCommentPublic Primer

Copy

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

checkedCommentsForBlocked

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
commentIds	string	Da
sso	string	Ne

Odgovor

Vraća: CheckBlockedCommentsResponse

Primer

checkedCommentsForBlocked Primer

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

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
blockFromCommentParams	BlockFromCommentParams	Yes
options	const BlockUserFromCommentOptions&	Yes

Odgovor

Vraća: BlockSuccess

Primer

blockUserFromComment Primer

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

Parameters

Naziv	Tip	Obavezno
tenantId	string	Da
urlId	string	Da
broadcastId	string	Da
commentData	CommentData	Da
options	const CreateCommentPublicOptions&	Da

Response

Vraća: SaveCommentsResponseWithPresence

Example

createCommentPublic Primer

Copy

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

deleteComment

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
options	const DeleteCommentOptions&	Yes

Odgovor

Vraća: DeleteCommentResult

Primer

deleteComment Primer

Copy

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

deleteCommentPublic

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
options	const DeleteCommentPublicOptions&	Yes

Odgovor

Vraća: PublicAPIDeleteCommentResponse

Primer

deleteCommentPublic Primer

Copy

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

deleteCommentVote

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
voteId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
options	const DeleteCommentVoteOptions&	Yes

Odgovor

Vraća: VoteDeleteResponse

Primer

Primer deleteCommentVote

Copy

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

flagComment

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
id	string	Da
options	const FlagCommentOptions&	Da

Odgovor

Vraća: FlagCommentResponse

Primer

flagComment Primer

Copy

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

getComment

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: APIGetCommentResponse

Primer

Primer getComment

Copy

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

getComments

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
options	const GetCommentsOptions&	Yes

Odgovor

Vraća: APIGetCommentsResponse

Primer

getComments Primer

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();
        // koristite odgovor po potrebi
    } catch (const std::exception& e) {
        // obradite grešku
    }
});

getCommentsPublic

req tenantId urlId

Parametri

Ime	Tip	Obavezno
tenantId	string	Da
urlId	string	Da
options	const GetCommentsPublicOptions&	Da

Odgovor

Vraća: GetCommentsResponseWithPresence_PublicComment_

Primer

Primer getCommentsPublic

Copy

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

getCommentText

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
options	const GetCommentTextOptions&	Yes

Odgovor

Vraća: PublicAPIGetCommentTextResponse

Primer

Primer getCommentText

Copy

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

getCommentVoteUserNames

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
commentId	string	Da
dir	int32_t	Da
sso	string	Ne

Odgovor

Vraća: GetCommentVoteUserNamesSuccessResponse

Primer

getCommentVoteUserNames Primer

Copy

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

lockComment

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Odgovor

Vraća: APIEmptyResponse

Primer

lockComment Primer

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, sno).then([](pplx::task<std::shared_ptr<APIEmptyResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){
    }
});

pinComment

Parametri

Ime	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Odgovor

Vraća: ChangeCommentPinStatusResponse

Primer

pinComment Primer

Copy

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

saveComment

Parametri

Name	Type	Required
tenantId	string	Yes
createCommentParams	CreateCommentParams	Yes
options	const SaveCommentOptions&	Yes

Odgovor

Vraća: APISaveCommentResponse

Primer

saveComment Primer

Copy

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

setCommentText

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
commentTextUpdateRequest	CommentTextUpdateRequest	Yes
options	const SetCommentTextOptions&	Yes

Odgovor

Vraća: PublicAPISetCommentTextResponse

Primer

setCommentText Primer

Copy

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

unBlockUserFromComment

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
unBlockFromCommentParams	UnBlockFromCommentParams	Yes
options	const UnBlockUserFromCommentOptions&	Yes

Odgovor

Vraća: UnblockSuccess

Primer

unBlockUserFromComment Primer

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

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
options	const UnFlagCommentOptions&	Yes

Odgovor

Vraća: FlagCommentResponse

Primer

unFlagComment Primer

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;
            // obradi status po potrebi
        }
    })
    .then([](pplx::task<void> previous) {
        try {
            previous.get();
        } catch (const std::exception& e) {
            // obradi grešku
        }
    });

unLockComment

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
commentId	string	Da
broadcastId	string	Da
sso	string	Ne

Odgovor

Vraća: APIEmptyResponse

Primer

Primer unLockComment

Copy

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

unPinComment

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
commentId	string	Da
broadcastId	string	Da
sso	string	Ne

Odgovor

Vraća: ChangeCommentPinStatusResponse

Primer

unPinComment Primer

Copy

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

updateComment

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
id	string	Da
updatableCommentParams	UpdatableCommentParams	Da
options	const UpdateCommentOptions&	Da

Odgovor

Vraća: APIEmptyResponse

Primer

updateComment Primer

Copy

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

voteComment

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
commentId	string	Da
urlId	string	Da
broadcastId	string	Da
voteBodyParams	VoteBodyParams	Da
options	const VoteCommentOptions&	Da

Odgovor

Vraća: VoteResponse

Primer

Primer voteComment

Copy

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

getCommentsForUser

Parametri

Naziv	Tip	Obavezno	Opis
options	const GetCommentsForUserOptions&	Da

Odgovor

Vraća: GetCommentsForUserResponse

Primer

getCommentsForUser Primer

Copy

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

addDomainConfig

Parametri

Name	Type	Required	Description
tenantId	string	Da
addDomainConfigParams	AddDomainConfigParams	Da

Odgovor

Vraća: AddDomainConfigResponse

Primer

addDomainConfig Primer

Copy

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

deleteDomainConfig

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
domain	string	Da

Odgovor

Vraća: DeleteDomainConfigResponse

Primer

deleteDomainConfig Primer

Copy

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

getDomainConfig

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
domain	string	Yes

Odgovor

Returns: GetDomainConfigResponse

Primer

Primer 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) {
            // obradi omogućenu moderaciju
        }
        if (theme) {
            // koristi vrednost teme
        }
    })
    .wait();

getDomainConfigs

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da

Odgovor

Vraća: GetDomainConfigsResponse

Primer

Primer getDomainConfigs

Copy

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

patchDomainConfig

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
domainToUpdate	string	Da
patchDomainConfigParams	PatchDomainConfigParams	Da

Odgovor

Vraća: PatchDomainConfigResponse

Primer

patchDomainConfig Primer

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) {
        // rukovanje uspehom
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* rukovanje greškom */ }
    });

putDomainConfig

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
domainToUpdate	string	Yes
updateDomainConfigParams	UpdateDomainConfigParams	Yes

Odgovor

Vraća: PutDomainConfigResponse

Primer

putDomainConfig Primer

Copy

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

createEmailTemplate

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
createEmailTemplateBody	CreateEmailTemplateBody	Da

Odgovor

Vraća: CreateEmailTemplateResponse

Primer

createEmailTemplate Primer

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

Parametri

Name	Type	Required	Description
tenantId	string	Da
id	string	Da

Odgovor

Vraća: APIEmptyResponse

Primer

deleteEmailTemplate Primer

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

Parametri

Ime	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
errorId	string	Yes

Odgovor

Vraća: APIEmptyResponse

Primer

deleteEmailTemplateRenderError Primer

Copy

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

getEmailTemplate

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: GetEmailTemplateResponse

Primer

getEmailTemplate Primer

Copy

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

getEmailTemplateDefinitions

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes

Odgovor

Vraća: GetEmailTemplateDefinitionsResponse

Primer

Primer getEmailTemplateDefinitions

Copy

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

getEmailTemplateRenderErrors

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
skip	double	No

Odgovor

Vraća: GetEmailTemplateRenderErrorsResponse

Primer

getEmailTemplateRenderErrors Primer

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();
            // Koristite odgovor po potrebi
        } catch (const std::exception& ex) {
            // Obradite grešku
        }
    });

getEmailTemplates

Parameters

Name	Type	Required	Description
tenantId	string	Yes
skip	double	No

Response

Returns: GetEmailTemplatesResponse

Example

getEmailTemplates Primer

Copy

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

renderEmailTemplate

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
renderEmailTemplateBody	RenderEmailTemplateBody	Yes
locale	string	No

Odgovor

Vraća: RenderEmailTemplateResponse

Primer

renderEmailTemplate Primer

Copy

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

updateEmailTemplate

Parametri

Name	Type	Required
tenantId	string	Da
id	string	Da
updateEmailTemplateBody	UpdateEmailTemplateBody	Da

Odgovor

Vraća: APIEmptyResponse

Primer

updateEmailTemplate Primer

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) {
        // obrada uspeha
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception &) { /* obrada greške */ }
    });

getEventLog

req tenantId urlId userIdWS

Parametri

Ime	Tip	Obavezno
tenantId	string	Da
urlId	string	Da
userIdWS	string	Da
startTime	int64_t	Da
endTime	int64_t	Ne

Odgovor

Vraća: GetEventLogResponse

Primer

Primer getEventLog

Copy

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

getGlobalEventLog

req tenantId urlId userIdWS

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
urlId	string	Yes
userIdWS	string	Yes
startTime	int64_t	Yes
endTime	int64_t	No

Odgovor

Vraća: GetEventLogResponse

Primer

getGlobalEventLog Primer

Copy

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

createFeedPost

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
createFeedPostParams	CreateFeedPostParams	Da
options	const CreateFeedPostOptions&	Da

Odgovor

Vraća: CreateFeedPostsResponse

Primer

createFeedPost Primer

Copy

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

createFeedPostPublic

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
options	const CreateFeedPostPublicOptions&	Yes

Odgovor

Vraća: CreateFeedPostResponse

Primer

createFeedPostPublic Primer

Copy

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

deleteFeedPostPublic

Parametri

Ime	Tip	Obavezno
tenantId	string	Da
postId	string	Da
options	const DeleteFeedPostPublicOptions&	Da

Odgovor

Vraća: DeleteFeedPostPublicResponse

Primer

deleteFeedPostPublic Primer

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()) {
            // logika uspeha
        }
    });

getFeedPosts

req tenantId afterId

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetFeedPostsOptions&	Da

Odgovor

Vraća: GetFeedPostsResponse

Primer

Primer getFeedPosts

Copy

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

getFeedPostsPublic

req tenantId afterId

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetFeedPostsPublicOptions&	Da

Odgovor

Vraća: PublicFeedPostsResponse

Primer

Primer getFeedPostsPublic

Copy

auto options = GetFeedPostsPublicOptions{};
options.limit = boost::optional<int>{20};
options.before = boost::optional<utility::string_t>{U("2023-01-01T00:00:00Z")};
api->getFeedPostsPublic(U("my-tenant-123"), options).then([](pplx::task<std::shared_ptr<PublicFeedPostsResponse>> task){
    try{
        auto response = task.get();
        auto processed = std::make_shared<PublicFeedPostsResponse>(*response);
        // Koristi processed po potrebi
    }catch(const std::exception&){
        // Obradi grešku
    }
});

getFeedPostsStats

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
postIds	vector<string	Yes
sso	string	No

Odgovor

Vraća: FeedPostsStatsResponse

Primer

Primer getFeedPostsStats

Copy

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

getUserReactsPublic

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetUserReactsPublicOptions&	Da

Odgovor

Vraća: UserReactsResponse

Primer

Primer 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

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
postId	string	Da
reactBodyParams	ReactBodyParams	Da
options	const ReactFeedPostPublicOptions&	Da

Odgovor

Vraća: ReactFeedPostResponse

Primer

reactFeedPostPublic Primer

Copy

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

updateFeedPost

Parametri

Ime	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
feedPost	FeedPost	Yes

Odgovor

Vraća: APIEmptyResponse

Primer

updateFeedPost Primer

Copy

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

updateFeedPostPublic

Parametri

Ime	Tip	Obavezno
tenantId	string	Yes
postId	string	Yes
updateFeedPostParams	UpdateFeedPostParams	Yes
options	const UpdateFeedPostPublicOptions&	Yes

Odgovor

Vraća: CreateFeedPostResponse

Primer

Primer updateFeedPostPublic

Copy

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

flagCommentPublic

Parametri

Ime	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
isFlagged	bool	Yes
sso	string	No

Odgovor

Vraća: APIEmptyResponse

Primer

flagCommentPublic Primer

Copy

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

getGifLarge

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Yes
largeInternalURLSanitized	string	Yes

Odgovor

Vraća: GifGetLargeResponse

Primer

Primer 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

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
search	string	Da
options	const GetGifsSearchOptions&	Da

Odgovor

Vraća: GetGifsSearchResponse

Primer

getGifsSearch Primer

Copy

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

getGifsTrending

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Yes
options	const GetGifsTrendingOptions&	Yes

Odgovor

Vraća: GetGifsTrendingResponse

Primer

Primer getGifsTrending

Copy

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

addHashTag

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
createHashTagBody	CreateHashTagBody	Da

Odgovor

Vraća: CreateHashTagResponse

Primer

addHashTag Primer

Copy

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

addHashTagsBulk

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Yes
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Yes

Odgovor

Vraća: BulkCreateHashTagsResponse

Primer

addHashTagsBulk Primer

Copy

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

deleteHashTag

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
tag	string	Da
deleteHashTagRequestBody	DeleteHashTagRequestBody	Da

Odgovor

Vraća: APIEmptyResponse

Primer

Primer 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

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
page	double	Ne

Odgovor

Vraća: GetHashTagsResponse

Primer

Primer 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);
        // koristi odgovor
    } catch (const std::exception&) {
        // obradi grešku
    }
});

patchHashTag

Parametri

Ime	Tip	Obavezno
tenantId	string	Yes
tag	string	Yes
updateHashTagBody	UpdateHashTagBody	Yes

Odgovor

Vraća: UpdateHashTagResponse

Primer

patchHashTag Primer

Copy

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

deleteModerationVote

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
voteId	string	Yes
options	const DeleteModerationVoteOptions&	Yes

Odgovor

Vraća: VoteDeleteResponse

Primer

deleteModerationVote Primer

Copy

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

getApiComments

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetApiCommentsOptions&	Da

Odgovor

Vraća: ModerationAPIGetCommentsResponse

Primer

Primer getApiComments

Copy

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

getApiExportStatus

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Yes
options	const GetApiExportStatusOptions&	Yes

Odgovor

Vraća: ModerationExportStatusResponse

Primer

Primer getApiExportStatus

Copy

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

getApiIds

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
options	const GetApiIdsOptions&	Yes

Odgovor

Returns: ModerationAPIGetCommentIdsResponse

Primer

getApiIds Primer

Copy

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

getBanUsersFromComment

Parametri

Ime	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Odgovor

Vraća: GetBannedUsersFromCommentResponse

Primer

Primer 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

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
commentId	string	Da
sso	string	Ne

Odgovor

Vraća: GetCommentBanStatusResponse

Primer

getCommentBanStatus Primer

Copy

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

getCommentChildren

Parametri

Ime	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Odgovor

Vraća: ModerationAPIChildCommentsResponse

Primer

Primer getCommentChildren

Copy

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

getCount

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
options	const GetCountOptions&	Yes

Odgovor

Vraća: ModerationAPICountCommentsResponse

Primer

getCount Primer

Copy

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

getCounts

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Da
sso	string	Ne

Odgovor

Vraća: GetBannedUsersCountResponse

Primer

getCounts Primer

Copy

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

getLogs

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Odgovor

Vraća: ModerationAPIGetLogsResponse

Primer

Primer getLogs

Copy

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

getManualBadges

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
sso	string	Ne

Odgovor

Returns: GetTenantManualBadgesResponse

Primer

Primer 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();
            // obradi odgovor, npr. response->badgeList
        } catch (const std::exception& ex) {
            // obradi grešku
        }
    });

getManualBadgesForUser

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
options	const GetManualBadgesForUserOptions&	Yes

Odgovor

Vraća: GetUserManualBadgesResponse

Primer

getManualBadgesForUser Primer

Copy

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

getModerationComment

Parametri

Name	Type	Required
tenantId	string	Da
commentId	string	Da
options	const GetModerationCommentOptions&	Da

Odgovor

Vraća: ModerationAPICommentResponse

Primer

getModerationComment Primer

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();
            // Obradi odgovor po potrebi
        } catch (const std::exception& ex) {
            // Obradi grešku
        }
    });

getModerationCommentText

Parametri

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

Odgovor

Vraća: GetCommentTextResponse

Primer

getModerationCommentText Primer

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, sno)
    .then([](pplx::task<std::shared_ptr<GetCommentTextResponse>> t) {
        try {
            auto resp = t.get();
            auto text = std::make_shared<std::string>(resp->commentText);
        } catch (const std::exception&) {
        }
    });

getPreBanSummary

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
commentId	string	Da
options	const GetPreBanSummaryOptions&	Da

Odgovor

Vraća: PreBanSummary

Primer

getPreBanSummary Primer

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();
            // obradi rezime
        } catch (const std::exception&) {
            // obradi grešku
        }
    });

getSearchCommentsSummary

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetSearchCommentsSummaryOptions&	Da

Odgovor

Vraća: ModerationCommentSearchResponse

Primer

getSearchCommentsSummary Primer

Copy

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

getSearchPages

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetSearchPagesOptions&	Da

Odgovor

Vraća: ModerationPageSearchResponse

Primer

Primer 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();
            // koristi odgovor
        } catch (const std::exception& e) {
            // obradi grešku
        }
    });

getSearchSites

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetSearchSitesOptions&	Da

Odgovor

Vraća: ModerationSiteSearchResponse

Primer

Primer 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 obrade
           }
       } catch (const std::exception&) {
           // obrada greške
       }
   });

getSearchSuggest

Parameters

Ime	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetSearchSuggestOptions&	Da

Response

Vraća: ModerationSuggestResponse

Example

Primer getSearchSuggest

Copy

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

getSearchUsers

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetSearchUsersOptions&	Da

Odgovor

Vraća: ModerationUserSearchResponse

Primer

getSearchUsers Primer

Copy

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

getTrustFactor

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
options	const GetTrustFactorOptions&	Yes

Odgovor

Vraća: GetUserTrustFactorResponse

Primer

Primer getTrustFactor

Copy

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

getUserBanPreference

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
sso	string	No

Odgovor

Returns: APIModerateGetUserBanPreferencesResponse

Primer

Primer getUserBanPreference

Copy

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

getUserInternalProfile

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Yes
options	const GetUserInternalProfileOptions&	Yes

Odgovor

Vraća: GetUserInternalProfileResponse

Primer

getUserInternalProfile Primer

Copy

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

postAdjustCommentVotes

Parametri

Ime	Tip	Obavezno
tenantId	string	Da
commentId	string	Da
adjustCommentVotesParams	AdjustCommentVotesParams	Da
options	const PostAdjustCommentVotesOptions&	Da

Odgovor

Vraća: AdjustVotesResponse

Primer

postAdjustCommentVotes Primer

Copy

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

postApiExport

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Da
options	const PostApiExportOptions&	Da

Odgovor

Vraća: ModerationExportResponse

Primer

postApiExport Primer

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) {
            // obradi uspešan odgovor izvoza
        }
    })
    .wait();

postBanUserFromComment

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
commentId	string	Da
options	const PostBanUserFromCommentOptions&	Da

Odgovor

Vraća: BanUserFromCommentResult

Primer

postBanUserFromComment Primer

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) {
        // obrada rezultata
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* obrada greške */ }
    });

postBanUserUndo

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
banUserUndoParams	BanUserUndoParams	Da
sso	string	Ne

Odgovor

Vraća: APIEmptyResponse

Primer

postBanUserUndo Primer

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

postBulkPreBanSummary

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
bulkPreBanParams	BulkPreBanParams	Da
options	const PostBulkPreBanSummaryOptions&	Da

Odgovor

Vraća: BulkPreBanSummary

Primer

postBulkPreBanSummary Primer

Copy

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

postCommentsByIds

Parametri

Name	Type	Required
tenantId	string	Da
commentsByIdsParams	CommentsByIdsParams	Da
sso	string	Ne

Odgovor

Vraća: ModerationAPIChildCommentsResponse

Primer

postCommentsByIds Primer

Copy

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

postFlagComment

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
options	const PostFlagCommentOptions&	Yes

Odgovor

Vraća: APIEmptyResponse

Primer

postFlagComment Primer

Copy

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

postRemoveComment

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
options	const PostRemoveCommentOptions&	Yes

Odgovor

Vraća: PostRemoveCommentApiResponse

Primer

postRemoveComment Primer

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();
            // Obradi odgovor
        } catch (const std::exception& ex) {
            // Rukuj greškom
        }
    });

postRestoreDeletedComment

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
options	const PostRestoreDeletedCommentOptions&	Yes

Odgovor

Vraća: APIEmptyResponse

Primer

postRestoreDeletedComment Primer

Copy

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

postSetCommentApprovalStatus

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentApprovalStatusOptions&	Yes

Odgovor

Vraća: SetCommentApprovedResponse

Primer

postSetCommentApprovalStatus Primer

Copy

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

postSetCommentReviewStatus

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentReviewStatusOptions&	Yes

Odgovor

Vraća: APIEmptyResponse

Primer

postSetCommentReviewStatus Primer

Copy

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

postSetCommentSpamStatus

Parametri

Ime	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentSpamStatusOptions&	Yes

Odgovor

Vraća: APIEmptyResponse

Primer

postSetCommentSpamStatus Primer

Copy

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

postSetCommentText

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
setCommentTextParams	SetCommentTextParams	Yes
options	const PostSetCommentTextOptions&	Yes

Odgovor

Vraća: SetCommentTextResponse

Primer

postSetCommentText Primer

Copy

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

postUnFlagComment

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
commentId	string	Da
options	const PostUnFlagCommentOptions&	Da

Odgovor

Vraća: APIEmptyResponse

Primer

postUnFlagComment Primer

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) {
        // obrada se može izvršiti ovde
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

postVote

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
commentId	string	Da
options	const PostVoteOptions&	Da

Odgovor

Vraća: VoteResponse

Primer

postVote Primer

Copy

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

putAwardBadge

Parametri

Ime	Tip	Obavezno
tenantId	string	Da
badgeId	string	Da
options	const PutAwardBadgeOptions&	Da

Odgovor

Vraća: AwardUserBadgeResponse

Primer

putAwardBadge primer

Copy

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

putCloseThread

Parametri

Ime	Tip	Obavezno
tenantId	string	Da
urlId	string	Da
sso	string	Ne

Odgovor

Vraća: APIEmptyResponse

Primer

putCloseThread Primer

Copy

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

putRemoveBadge

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
badgeId	string	Da
options	const PutRemoveBadgeOptions&	Da

Odgovor

Vraća: RemoveUserBadgeResponse

Primer

putRemoveBadge Primer

Copy

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

putReopenThread

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
urlId	string	Yes
sso	string	No

Odgovor

Vraća: APIEmptyResponse

Primer

putReopenThread Primer

Copy

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

setTrustFactor

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
options	const SetTrustFactorOptions&	Da

Odgovor

Vraća: SetUserTrustFactorResponse

Primer

Primer setTrustFactor

Copy

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

createModerator

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
createModeratorBody	CreateModeratorBody	Yes

Odgovor

Vraća: CreateModeratorResponse

Primer

Primer createModerator

Copy

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

deleteModerator

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
sendEmail	string	No

Odgovor

Vraća: APIEmptyResponse

Primer

deleteModerator Primer

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

getModerator

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
id	string	Yes

Odgovor

Vraća: GetModeratorResponse

Primer

Primer getModerator

Copy

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

getModerators

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
skip	double	No

Odgovor

Vraća: GetModeratorsResponse

Primer

getModerators Primer

Copy

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

sendInvite

Parametri

Ime	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
fromName	string	Yes

Odgovor

Vraća: APIEmptyResponse

Primer

sendInvite Primer

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) {
    // obradi uspešno slanje poziva
});

updateModerator

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
updateModeratorBody	UpdateModeratorBody	Yes

Odgovor

Vraća: APIEmptyResponse

Primer

Primer updateModerator

Copy

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

deleteNotificationCount

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
id	string	Yes

Odgovor

Vraća: APIEmptyResponse

Primer

Primer deleteNotificationCount

Copy

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

getCachedNotificationCount

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: GetCachedNotificationCountResponse

Primer

getCachedNotificationCount Primer

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();
            // obradi odgovor
        } catch (const std::exception&) {
            // obradi grešku
        }
    });

getNotificationCount

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetNotificationCountOptions&	Da

Odgovor

Vraća: GetNotificationCountResponse

Primer

Primer getNotificationCount

Copy

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

getNotifications

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
options	const GetNotificationsOptions&	Yes

Odgovor

Vraća: GetNotificationsResponse

Primer

Primer getNotifications

Copy

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

updateNotification

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
updateNotificationBody	UpdateNotificationBody	Yes
userId	string	No

Odgovor

Vraća: APIEmptyResponse

Primer

Primjer 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

Parameters

Name	Type	Required
tenantId	string	Da
urlId	string	Da
title	string	Ne

Response

Vraća: CreateV1PageReact

Example

Primer createV1PageReact

Copy

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

createV2PageReact

Parametri

Ime	Tip	Obavezno
tenantId	string	Da
urlId	string	Da
id	string	Da
title	string	Ne

Odgovor

Vraća: CreateV1PageReact

Primer

Primer createV2PageReact

Copy

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

deleteV1PageReact

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
urlId	string	Da

Odgovor

Vraća: CreateV1PageReact

Primer

deleteV1PageReact Primer

Copy

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

deleteV2PageReact

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
urlId	string	Da
id	string	Da

Odgovor

Vraća: CreateV1PageReact

Primer

deleteV2PageReact Primer

Copy

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

getV1PageLikes

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
urlId	string	Da

Odgovor

Returns: GetV1PageLikes

Primer

Primer getV1PageLikes

Copy

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

getV2PageReacts

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
urlId	string	Da

Odgovor

Vraća: GetV2PageReacts

Primer

Primer getV2PageReacts

Copy

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

getV2PageReactUsers

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
urlId	string	Yes
id	string	Yes

Odgovor

Vraća: GetV2PageReactUsersResponse

Primer

Primer getV2PageReactUsers

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto urlId = utility::conversions::to_string_t("page-456");
auto id = utility::conversions::to_string_t("react-789");
boost::optional<utility::string_t> maybeFilter;
api->getV2PageReactUsers(tenantId, urlId, id).then([](pplx::task<std::shared_ptr<GetV2PageReactUsersResponse>> task){
    try{
        auto response = task.get();
        // Koristite odgovor po potrebi
    }catch(const std::exception&){
        // Obradi grešku
    }
});

addPage

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
createAPIPageData	CreateAPIPageData	Da

Odgovor

Vraća: AddPageAPIResponse

Primer

addPage Primer

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) {
            // obradi uspešno dodavanje
        } else {
            // obradi grešku
        }
    });

deletePage

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: DeletePageAPIResponse

Primer

deletePage Primer

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();
           // obradi odgovor po potrebi
       } catch (const std::exception& ex) {
           // obradi grešku
       }
   });

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

Vraća: PageUsersOfflineResponse

Example

Primer 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

Trenutno online gledatelji stranice: ljudi čija je websocket sesija pretplaćena na stranicu upravo sada.
Vraća anonCount + totalCount (pretplatnici u cijeloj sobi, uključujući anonimne gledaoce koje ne nabrajamo).

Parametri

Ime	Tip	Obavezno
tenantId	string	Da
urlId	string	Da
options	const GetOnlineUsersOptions&	Da

Odgovor

Vraća: PageUsersOnlineResponse

Primer

Primer getOnlineUsers

Copy

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

getPageByURLId

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
urlId	string	Yes

Odgovor

Vraća: GetPageByURLIdAPIResponse

Primer

Primer 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

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da

Odgovor

Vraća: GetPagesAPIResponse

Primer

getPages Primer

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.

Parametri

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

Odgovor

Vraća: GetPublicPagesResponse

Primer

Primer 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

Skup informacija o korisnicima za najamnika. Dati userIds, vraća informacije za prikaz iz User / SSOUser.
Koristi se u vidžetu komentara za obogaćivanje korisnika koji su upravo pojavili putem događaja prisustva.
Bez konteksta stranice: privatnost se primenjuje uniformno (privatni profili su maskirani).

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
ids	string	Yes

Odgovor

Vraća: PageUsersInfoResponse

Primer

Primer getUsersInfo

Copy

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

patchPage

Parameters

Ime	Tip	Obavezno
tenantId	string	Da
id	string	Da
updateAPIPageData	UpdateAPIPageData	Da

Response

Vraća: PatchPageAPIResponse

Example

patchPage Primer

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

deletePendingWebhookEvent

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
id	string	Yes

Odgovor

Vraća: APIEmptyResponse

Primer

deletePendingWebhookEvent Primer

Copy

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

getPendingWebhookEventCount

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetPendingWebhookEventCountOptions&	Da

Odgovor

Vraća: GetPendingWebhookEventCountResponse

Primer

getPendingWebhookEventCount Primer

Copy

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

getPendingWebhookEvents

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetPendingWebhookEventsOptions&	Da

Odgovor

Vraća: GetPendingWebhookEventsResponse

Primer

getPendingWebhookEvents Primer

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

Parameters

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
createQuestionConfigBody	CreateQuestionConfigBody	Da

Response

Vraća: CreateQuestionConfigResponse

Example

Primer 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

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
id	string	Yes

Odgovor

Vraća: APIEmptyResponse

Primer

deleteQuestionConfig Primer

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) {
        // obradi uspješno brisanje
    })
    .then([](pplx::task<void> t) {
        try {
            t.get();
        } catch (const std::exception&) {
            // obradi grešku
        }
    });

getQuestionConfig

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: GetQuestionConfigResponse

Primer

getQuestionConfig Primer

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();
            // Koristite odgovor po potrebi
        } catch (const std::exception&) {
            // Obradite grešku
        }
    });

getQuestionConfigs

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Da
skip	double	Ne

Odgovor

Vraća: GetQuestionConfigsResponse

Primer

getQuestionConfigs Primer

Copy

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

updateQuestionConfig

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
updateQuestionConfigBody	UpdateQuestionConfigBody	Yes

Odgovor

Returns: APIEmptyResponse

Primer

Primer updateQuestionConfig

Copy

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

createQuestionResult

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Da
createQuestionResultBody	CreateQuestionResultBody	Da

Odgovor

Vraća: CreateQuestionResultResponse

Primer

createQuestionResult Primer

Copy

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

deleteQuestionResult

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Yes
id	string	Yes

Odgovor

Vraća: APIEmptyResponse

Primer

deleteQuestionResult Primer

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();
                // uspešno rukovanje
            }
            catch ( const std::exception& e )
            {
                // obrada greške
            }
        } );
}

getQuestionResult

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: GetQuestionResultResponse

Primer

Primer getQuestionResult

Copy

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

getQuestionResults

Parametri

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

Odgovor

Vraća: GetQuestionResultsResponse

Primer

Primer 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();
        // obradi odgovor
    });

updateQuestionResult

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
updateQuestionResultBody	UpdateQuestionResultBody	Yes

Odgovor

Vraća: APIEmptyResponse

Primer

updateQuestionResult Primer

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

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
options	const AggregateQuestionResultsOptions&	Da

Odgovor

Vraća: AggregateQuestionResultsResponse

Primer

aggregateQuestionResults Primer

Copy

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

bulkAggregateQuestionResults

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Da
forceRecalculate	bool	Ne

Odgovor

Vraća: BulkAggregateQuestionResultsResponse

Primer

bulkAggregateQuestionResults Primer

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

Parameters

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
options	const CombineCommentsWithQuestionResultsOptions&	Yes

Odgovor

Vraća: CombineQuestionResultsWithCommentsResponse

Primer

combineCommentsWithQuestionResults Primer

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);
            // Koristite kombinovano po potrebi
        }catch(const std::exception&){
        }
    });

addSSOUser

Parametri

Name	Type	Required	Description
tenantId	string	Da
createAPISSOUserData	CreateAPISSOUserData	Da

Odgovor

Vraća: AddSSOUserAPIResponse

Primer

addSSOUser Primer

Copy

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

deleteSSOUser

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
options	const DeleteSSOUserOptions&	Yes

Odgovor

Vraća: DeleteSSOUserAPIResponse

Primer

deleteSSOUser Primer

Copy

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

getSSOUserByEmail

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
email	string	Da

Odgovor

Vraća: GetSSOUserByEmailAPIResponse

Primer

getSSOUserByEmail Primer

Copy

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

getSSOUserById

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
id	string	Yes

Odgovor

Vraća: GetSSOUserByIdAPIResponse

Primer

getSSOUserById Primer

Copy

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

getSSOUsers

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Yes
skip	int32_t	No

Odgovor

Vraća: GetSSOUsersResponse

Primer

getSSOUsers Primer

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

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
updateAPISSOUserData	UpdateAPISSOUserData	Yes
updateComments	bool	No

Odgovor

Vraća: PatchSSOUserAPIResponse

Primer

patchSSOUser Primer

Copy

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

putSSOUser

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
updateAPISSOUserData	UpdateAPISSOUserData	Yes
updateComments	bool	No

Odgovor

Vraća: PutSSOUserAPIResponse

Primer

putSSOUser Primer

Copy

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

createSubscription

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Da

Odgovor

Vraća: CreateSubscriptionAPIResponse

Primer

createSubscription Primer

Copy

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

deleteSubscription

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
id	string	Da
userId	string	Ne

Odgovor

Vraća: DeleteSubscriptionAPIResponse

Primer

deleteSubscription Primer

Copy

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

getSubscriptions

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
userId	string	No

Odgovor

Vraća: GetSubscriptionsAPIResponse

Primer

Primer 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();
            // obradi odgovor
        } catch (const std::exception& e) {
            // obradi grešku
        }
    }
);

updateSubscription

Parametri

Ime	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	Yes
userId	string	No

Odgovor

Vraća: UpdateSubscriptionAPIResponse

Primer

Primer 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

Parameters

Name	Type	Required	Description
tenantId	string	Da
options	const GetTenantDailyUsagesOptions&	Da

Response

Vraća: GetTenantDailyUsagesResponse

Primer

Primer getTenantDailyUsages

Copy

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

createTenantPackage

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
createTenantPackageBody	CreateTenantPackageBody	Da

Odgovor

Vraća: CreateTenantPackageResponse

Primer

createTenantPackage Primer

Copy

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

deleteTenantPackage

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: APIEmptyResponse

Primer

deleteTenantPackage Primer

Copy

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

getTenantPackage

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Yes
id	string	Yes

Odgovor

Vraća: GetTenantPackageResponse

Primer

getTenantPackage Primer

Copy

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

getTenantPackages

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
skip	double	No

Odgovor

Vraća: GetTenantPackagesResponse

Primer

Primer getTenantPackages

Copy

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

replaceTenantPackage

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
id	string	Da
replaceTenantPackageBody	ReplaceTenantPackageBody	Da

Odgovor

Vraća: APIEmptyResponse

Primer

replaceTenantPackage Primer

Copy

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

updateTenantPackage

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
id	string	Da
updateTenantPackageBody	UpdateTenantPackageBody	Da

Odgovor

Vraća: APIEmptyResponse

Primer

updateTenantPackage Primer

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();
            // obrada uspjeha
        } catch (const std::exception& ex) {
            // obrada greške
        }
    });

createTenantUser

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Da
createTenantUserBody	CreateTenantUserBody	Da

Odgovor

Vraća: CreateTenantUserResponse

Primer

createTenantUser Primer

Copy

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

deleteTenantUser

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
options	const DeleteTenantUserOptions&	Yes

Odgovor

Vraća: APIEmptyResponse

Primer

deleteTenantUser Primer

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

Ime	Tip	Obavezno	Opis
tenantId	string	Yes
id	string	Yes

Response

Vraća: GetTenantUserResponse

Primer

getTenantUser Primer

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();
            // Koristite odgovor po potrebi
        } catch (const std::exception&) {
            // Obrada greške
        }
    });

getTenantUsers

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
skip	double	Ne

Odgovor

Vraća: GetTenantUsersResponse

Primer

Primer getTenantUsers

Copy

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

replaceTenantUser

Parametri

Ime	Tip	Obavezno
tenantId	string	Da
id	string	Da
replaceTenantUserBody	ReplaceTenantUserBody	Da
updateComments	string	Ne

Odgovor

Returns: APIEmptyResponse

Primer

replaceTenantUser Primer

Copy

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

sendLoginLink

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
id	string	Da
redirectURL	string	Ne

Odgovor

Vraća: APIEmptyResponse

Primer

sendLoginLink Primer

Copy

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

updateTenantUser

Parametri

Name	Type	Required
tenantId	string	Da
id	string	Da
updateTenantUserBody	UpdateTenantUserBody	Da
updateComments	string	Ne

Odgovor

Vraća: APIEmptyResponse

Primer

updateTenantUser Primer

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

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
createTenantBody	CreateTenantBody	Da

Odgovor

Vraća: CreateTenantResponse

Primer

createTenant Primer

Copy

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

deleteTenant

Parametri

Name	Type	Required
tenantId	string	Da
id	string	Da
sure	string	Ne

Odgovor

Vraća: APIEmptyResponse

Primer

Primer deleteTenant

Copy

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

getTenant

Parametri

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Odgovor

Vraća: GetTenantResponse

Primer

Primer getTenant

Copy

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

getTenants

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetTenantsOptions&	Da

Odgovor

Vraća: GetTenantsResponse

Primer

Primer getTenants

Copy

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

updateTenant

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
id	string	Da
updateTenantBody	UpdateTenantBody	Da

Odgovor

Vraća: APIEmptyResponse

Primer

Primer updateTenant

Copy

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

changeTicketState

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
userId	string	Da
id	string	Da
changeTicketStateBody	ChangeTicketStateBody	Da

Odgovor

Vraća: ChangeTicketStateResponse

Primer

changeTicketState Primer

Copy

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

createTicket

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
userId	string	Da
createTicketBody	CreateTicketBody	Da

Odgovor

Vraća: CreateTicketResponse

Primer

Primer 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();
        // Koristite odgovor po potrebi
    }catch(const std::exception&){
        // Obradite grešku
    }
});

getTicket

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
userId	string	No

Odgovor

Vraća: GetTicketResponse

Primer

Primer getTicket

Copy

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

getTickets

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetTicketsOptions&	Da

Odgovor

Vraća: GetTicketsResponse

Primer

getTickets Primer

Copy

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

getTranslations

Parametri

Ime	Tip	Obavezno
r_namespace	string	Yes
component	string	Yes
options	const GetTranslationsOptions&	Yes

Odgovor

Vraća: GetTranslationsResponse

Primer

getTranslations Primer

Copy

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

uploadImage

Upload and resize an image

Parameters

Naziv	Tip	Obavezno
tenantId	string	Da
file	HttpContent	Da
options	const UploadImageOptions&	Da

Response

Vraća: UploadImageResponse

Example

uploadImage Primer

Copy

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

getUserBadgeProgressById

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: APIGetUserBadgeProgressResponse

Primer

getUserBadgeProgressById Primer

Copy

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

getUserBadgeProgressByUserId

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
userId	string	Da

Odgovor

Vraća: APIGetUserBadgeProgressResponse

Primer

Primer 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

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetUserBadgeProgressListOptions&	Da

Odgovor

Vraća: APIGetUserBadgeProgressListResponse

Primer

Primer 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) {
            // obradi značku
        }
    });

createUserBadge

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Da
createUserBadgeParams	CreateUserBadgeParams	Da

Odgovor

Vraća: APICreateUserBadgeResponse

Primer

createUserBadge Primer

Copy

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

deleteUserBadge

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
id	string	Yes

Odgovor

Vraća: APIEmptySuccessResponse

Primer

deleteUserBadge Primer

Copy

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

getUserBadge

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Yes
id	string	Yes

Odgovor

Vraća: APIGetUserBadgeResponse

Primer

getUserBadge Primer

Copy

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

getUserBadges

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
options	const GetUserBadgesOptions&	Yes

Odgovor

Returns: APIGetUserBadgesResponse

Primer

Primer getUserBadges

Copy

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

updateUserBadge

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
id	string	Yes
updateUserBadgeParams	UpdateUserBadgeParams	Yes

Odgovor

Vraća: APIEmptySuccessResponse

Primer

updateUserBadge Primer

Copy

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

getUserNotificationCount

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
sso	string	Ne

Odgovor

Vraća: GetUserNotificationCountResponse

Primer

Primer getUserNotificationCount

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("user@example.com");
api->getUserNotificationCount(tenantId, sso).then([](pplx::task<std::shared_ptr<GetUserNotificationCountResponse>> t){
    try{
        auto resp = t.get();
        // use resp as needed
    }catch(const std::exception&){
        // handle error
    }
});

getUserNotifications

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Da
options	const GetUserNotificationsOptions&	Da

Odgovor

Vraća: GetMyNotificationsResponse

Primer

getUserNotifications Primer

Copy

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

resetUserNotificationCount

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Yes
sso	string	No

Odgovor

Vraća: ResetUserNotificationsResponse

Primer

resetUserNotificationCount Primer

Copy

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

resetUserNotifications

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
options	const ResetUserNotificationsOptions&	Yes

Odgovor

Vraća: ResetUserNotificationsResponse

Primer

resetUserNotifications Primer

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

updateUserNotificationCommentSubscriptionStatus

Omogući ili onemogući obaveštenja za određeni komentar.

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
notificationId	string	Da
optedInOrOut	string	Da
commentId	string	Da
sso	string	Ne

Odgovor

Vraća: UpdateUserNotificationCommentSubscriptionStatusResponse

Primer

updateUserNotificationCommentSubscriptionStatus Primer

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 or disable notifications for a page. When users are subscribed to a page, notifications are created for new root comments, and also

Parameters

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

Response

Vraća: UpdateUserNotificationPageSubscriptionStatusResponse

Primer

Primer updateUserNotificationPageSubscriptionStatus

Copy

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

updateUserNotificationStatus

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
notificationId	string	Da
newStatus	string	Da
sso	string	Ne

Odgovor

Vraća: UpdateUserNotificationStatusResponse

Primer

updateUserNotificationStatus Primer

Copy

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

getUserPresenceStatuses

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
urlIdWS	string	Yes
userIds	string	Yes

Odgovor

Vraća: GetUserPresenceStatusesResponse

Primer

getUserPresenceStatuses Primer

Copy

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

searchUsers

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
urlId	string	Da
options	const SearchUsersOptions&	Da

Odgovor

Vraća: SearchUsersResult

Primer

searchUsers Primer

Copy

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

getUser

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: GetUserResponse

Primer

Primer getUser

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user-789");
boost::optional<utility::string_t> optTag = boost::none;
api->getUser(tenantId, userId)
    .then([=](pplx::task<std::shared_ptr<GetUserResponse>> task) {
        try {
            auto response = task.get();
            if (!response) {
                response = std::make_shared<GetUserResponse>();
            }
            // obradi odgovor po potrebi
        } catch (const std::exception&) {
            // obradi grešku
        }
    });

createVote

Parametri

Naziv	Tip	Obavezno
tenantId	string	Yes
commentId	string	Yes
direction	string	Yes
options	const CreateVoteOptions&	Yes

Odgovor

Vraća: VoteResponse

Primer

createVote Primer

Copy

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

deleteVote

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
id	string	Da
editKey	string	Ne

Odgovor

Vraća: VoteDeleteResponse

Primer

deleteVote Primer

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();
        // Obradi odgovor po potrebi
    } catch (const std::exception&) {
        // Rukuj greškom
    }
});

getVotes

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
urlId	string	Yes

Odgovor

Vraća: GetVotesResponse

Primer

Primer 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 (...) {
        // obrada greške
    }
});

getVotesForUser

Parametri

Name	Type	Required
tenantId	string	Da
urlId	string	Da
options	const GetVotesForUserOptions&	Da

Odgovor

Vraća: GetVotesForUserResponse

Primer

getVotesForUser Primer

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) {
        // obradi odgovor, npr. iteriraj glasove
    }
});

Trebate pomoć?

Ako naiđete na bilo kakve probleme ili imate pitanja u vezi C++ SDK-a, molimo:

Doprinosi

Doprinosi su dobrodošli! Molimo posetite GitHub repozitorijum za smernice o doprinosu.

Jezik 🇷🇸 Srpski (Latinica)

Dokumentacija

Početak rada

API referenca

Korišćenje

Agregacija

Dnevnici audita

Autentifikacija

Blokiranje iz komentara

Provera blokiranih komentara

Komentari

Komentari za korisnika

Konfiguracije domena

Šabloni e-pošte

Dnevnik događaja

Objave u feedu

Označavanje komentara

Gifovi

Hashtagovi

Moderacija

Moderatori

Broj obaveštenja

Obaveštenja

Reakcije na stranici

Stranice

Webhook događaji na čekanju

Konfiguracije pitanja

Rezultati pitanja

Agregacija rezultata pitanja

SSO korisnici

Pretplate

Dnevna upotreba tenanta

Paketi tenanta

Korisnici tenanta

Tenanti

Tiketi

Prevodi

Otpremanje slike

Napredak korisničkih bedževa

Korisnički bedževi

Korisnička obaveštenja

Status prisutnosti korisnika

Pretraga korisnika

Korisnici

Glasovi

FastComments C++ SDK

Repozitorijum

Zahtevi

Instalacija

Instalacija zavisnosti

Izgradnja iz izvornog koda

Instalacija

Sadržaj biblioteke

Javni vs zaštićeni API‑ji

Brzi početak

Korišćenje autentifikovanih API-ja (DefaultAPI)

Korišćenje javnih API-ja (PublicAPI)

Korišćenje Moderacionih API-ja (ModerationApi)

Uobičajeni problemi

Pozivi ka API-ju: sinhrono vs asinhrono

Sinhroni pozivi sa .get()

Asinkroni pozivi sa .then()

Izbor između sinhronog i asinkronog

Beleške

Broadcast ID-jevi

SSO (Jedinstvena prijava)

Korišćenje SSO

Jednostavan SSO

Siguran SSO

Dokumentacija za FastComments

Dokumentacija za API krajnje tačke

Dokumentacija za modele

aggregate

Parametri

Odgovor

Primer

getAuditLogs

Parametri

Odgovor

Primer

Sinhroni pozivi sa `.get()`

Asinkroni pozivi sa `.then()`