FastComments C++ SDK

Ово је званични C++ SDK за FastComments.

Званични C++ SDK за FastComments API

Репозиторијум

Захтјеви

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

Инсталација

Instalirajte zavisnosti

sudo apt install libcpprest-dev libboost-all-dev

Kompiliranje iz izvornog koda

mkdir build
cd build
cmake ..
make

Instaliranje

sudo make install

Sadržaj biblioteke

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

Dokumentacija API klijentske biblioteke

Javni i zaštićeni API-ji

Za API klijenta postoje dvije klase, DefaultAPI i PublicAPI. DefaultAPI sadrži metode koje zahtijevaju vaš API key, a PublicAPI sadrži API pozive koji se mogu direktno izvršavati iz preglednika/mobilnog uređaja/itd. bez autentifikacije.

Брзи почетак

Коришћење аутентификованих API-ја (DefaultAPI)

Важно:

Морате поставити базни URL (cpp-restsdk генератор не чита то из OpenAPI спецификације)
Морате поставити ваш API кључ на ApiClient прије слања аутентификованих захтјева. Ако не, захтјеви ће бити одбијени са грешком 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>();

    // ОБАВЕЗНО: Поставите базни URL (изаберите вашу регију)
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));  // US
    // ИЛИ: config->setBaseUrl(utility::conversions::to_string_t("https://eu.fastcomments.com"));  // EU

    // ОБАВЕЗНО: Поставите ваш API кључ
    config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_API_KEY_HERE"));

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

    // Now make authenticated API calls
    return 0;
}

Коришћење јавних API-ја (PublicAPI)

Јавни ендпоинти не захтијевају аутентификацију:

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

    // ОБАВЕЗНО: Поставите базни 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);

    // Извршите јавне API позиве
    return 0;
}

Чести проблеми

"URI must contain a hostname" error: Убедите се да позовете config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) прије креирања ApiClient-а. cpp-restsdk генератор не чита аутоматски URL сервера из OpenAPI спецификације.
401 "missing-api-key" error: Убедите се да позовете config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) прије креирања DefaultAPI инстанце.
Wrong API class: Користите DefaultAPI за серверске аутентификоване захтјеве, PublicAPI за клијентске/јавне захтјеве.

Извршавање API позива: синхроно и асинхроно

Sve API metode u ovom SDK-u vraćaju pplx::task<std::shared_ptr<ResponseType>> iz C++ REST SDK-a. Ovo vam daje fleksibilnost u načinu rukovanja odgovorima API-ja.

Sinhroni pozivi sa `.get()`

Koristite .get() da blokirate pozivajuću nit dok zahtjev ne bude završen 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);

// Pozovite .get() da blokirate i dobijete rezultat sinhrono
auto response = api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    boost::none,  // page (stranica)
    boost::none,  // limit (limit)
    boost::none,  // skip (preskoči)
    boost::none,  // asTree (kao stablo)
    boost::none,  // skipChildren (preskoči potomke)
    boost::none,  // limitChildren (ograniči potomke)
    boost::none,  // maxTreeDepth (maksimalna dubina stabla)
    utility::conversions::to_string_t("your-url-id"),  // urlId (urlId)
    boost::none,  // userId (userId, ID korisnika)
    boost::none,  // anonUserId (anonUserId, ID anonimnog korisnika)
    boost::none,  // contextUserId (contextUserId, ID kontekstnog korisnika)
    boost::none,  // hashTag (hashTag)
    boost::none,  // parentId (parentId, ID roditelja)
    boost::none   // direction (direction)
).get();  // Blokira dok se HTTP zahtjev ne završi

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

Asinhroni pozivi sa `.then()`

Koristite .then() za neblokirajuće asinhrono izvršavanje sa 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);

// Koristite .then() za asinhrono izvršavanje zasnovano na callback-ovima
api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    boost::none, boost::none, boost::none, boost::none, boost::none,
    boost::none, boost::none,
    utility::conversions::to_string_t("your-url-id"),
    boost::none, boost::none, boost::none, boost::none, boost::none, boost::none
).then([](std::shared_ptr<GetComments_200_response> response) {
    // Ovo se izvršava asinhrono kada se zahtjev završi
    if (response && response->comments) {
        std::cout << "Found " << response->comments->size() << " comments" << std::endl;
    }
});

// Izvršavanje se nastavlja odmah bez blokiranja
std::cout << "Request sent, continuing..." << std::endl;

Izbor između sinhronog i asinhronog

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

.get() (Sinhrono blokiranje)

Blokira pozivajuću nit dok se HTTP zahtjev ne završi
Jednostavniji tok koda, lakše za razumijevanje
Pogodno za namjenske radne niti, batch obradu ili komandno-linijske alate
Nije pogodno za petlje događaja, GUI niti ili servere sa jednom niti

.then() (Asinhrono, neblokirajuće)

Vraća odmah, callback se izvršava kada se zahtjev završi
Ne blokira pozivajuću nit
Neophodno za arhitekture vođene događajima, GUI aplikacije ili petlje događaja sa jednom niti
Omogućava lančanje više operacija
Složeniji tok kontrole

Testni paket SDK-a koristi isključivo .get(), što je prikladno za testno okruženje gdje je blokiranje prihvatljivo.

Напомене

ИД-ови емитовања

Видећете да је потребно проследити broadcastId у неким API позивима. Када примите догађаје, добићете овај ID назад, па ћете знати да игноришете догађај ако планирате да оптимистички примените измјене на клијенту (што ћете вјероватно желети учинити јер пружа најбоље корисничко искуство). Прослиједите овдје UUID. ID треба да буде довољно јединствен да се не појави два пута у току сесије прегледника.

SSO (Једнократна пријава)

За примјере SSO-а, погледајте ниже.

Коришћење SSO

Једноставан 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;
}

Сигуран 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;
}

Документација за fastcomments

Документација за API крајње тачке

Сви URI-ји су релативни у односу на https://fastcomments.com

Класа	Метод	HTTP захтјев	Опис
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	Агрегира документе груписањем (ако је groupBy наведено) и примјеном више операција. Подржане су различите операције (нпр. sum, countDistinct, avg, итд.).
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	обавезно 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}
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	deleteCommentPublic	DELETE /comments/{tenantId}/{commentId}
PublicApi	deleteCommentVote	DELETE /comments/{tenantId}/{commentId}/vote/{voteId}
PublicApi	deleteFeedPostPublic	DELETE /feed-posts/{tenantId}/{postId}
PublicApi	flagCommentPublic	POST /flag-comment/{commentId}
PublicApi	getCommentText	GET /comments/{tenantId}/{commentId}/text
PublicApi	getCommentVoteUserNames	GET /comments/{tenantId}/{commentId}/votes
PublicApi	getCommentsPublic	GET /comments/{tenantId}	обавезно tenantId urlId
PublicApi	getEventLog	GET /event-log/{tenantId}	обавезно tenantId urlId userIdWS
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	обавезно tenantId afterId
PublicApi	getFeedPostsStats	GET /feed-posts/{tenantId}/stats
PublicApi	getGlobalEventLog	GET /event-log/global/{tenantId}	обавезно tenantId urlId userIdWS
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	lockComment	POST /comments/{tenantId}/{commentId}/lock
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}	Омогућава или онемогућава обавјештења за одређени коментар.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Омогућава или онемогућава обавјештења за страницу. Када су корисници претплаћени на страницу, обавјештења се креирају за нове коријенске коментаре, као и
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Пошаљи и промијени величину слике
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Документација за Моделе

Агрегација

Параметри

Name	Type	Required
tenantId	string	Да
aggregationRequest	AggregationRequest	Да
parentTenantId	string	Не
includeStats	bool	Не

Одговор

Враћа: AggregationResponse

Пример

aggregate Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
AggregationRequest aggReq;
boost::optional<utility::string_t> parentTenant = boost::optional<utility::string_t>(U("parent-org-456"));
boost::optional<bool> includeStats = boost::optional<bool>(true);
auto aggTask = api->aggregate(tenantId, aggReq, parentTenant, includeStats)
    .then([](pplx::task<std::shared_ptr<AggregationResponse>> t) {
        try {
            auto res = t.get();
            auto out = std::make_shared<AggregationResponse>(*res);
            return out;
        } catch (...) {
            return std::shared_ptr<AggregationResponse>();
        }
    });

getAuditLogs

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
limit	double	Ne
skip	double	Ne
order	SORT_DIR	Ne
after	double	Ne
before	double	Ne

Odgovor

Vraća: GetAuditLogs_200_response

Primjer

Primjer getAuditLogs

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> limit = 100;
boost::optional<double> skip = 0;
boost::optional<SORT_DIR> order = SORT_DIR::DESC;
boost::optional<double> after = 1633046400;
boost::optional<double> before = 1633132800;
api->getAuditLogs(tenantId, limit, skip, order, after, before)
.then([](pplx::task<std::shared_ptr<GetAuditLogs_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<GetAuditLogs_200_response>(*resp);
            (void)copy;
        }
    } catch (...) {
    }
});

blockFromCommentPublic

Parametri

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

Odgovor

Vraća: BlockFromCommentPublic_200_response

Primjer

blockFromCommentPublic Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654321");
PublicBlockFromCommentParams params;
params.reason = U("Repeated harassment");
params.durationMinutes = 1440;
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-token-abc123"));
auto placeholder = std::make_shared<BlockFromCommentPublic_200_response>();
api->blockFromCommentPublic(tenantId, commentId, params, sso)
.then([](pplx::task<std::shared_ptr<BlockFromCommentPublic_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) std::wcout << U("Comment blocked successfully\n");
        else std::wcout << U("Block request returned empty response\n");
    } catch (...) {
        std::wcout << U("Block request failed\n");
    }
});

unBlockCommentPublic

Параметри

Име	Тип	Обавезно
tenantId	string	Да
commentId	string	Да
publicBlockFromCommentParams	PublicBlockFromCommentParams	Да
sso	string	Не

Одговор

Враћа: UnBlockCommentPublic_200_response

Пример

Пример unBlockCommentPublic

Copy

auto publicParams = std::make_shared<PublicBlockFromCommentParams>();
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(utility::string_t(U("user@example.com")));
api->unBlockCommentPublic(utility::string_t(U("my-tenant-123")), utility::string_t(U("comment-98765")), *publicParams, sso)
.then([](pplx::task<std::shared_ptr<UnBlockCommentPublic_200_response>> task) {
    try {
        auto resp = task.get();
        if (resp) std::cout << "Unblocked comment successfully" << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Unblock failed: " << e.what() << std::endl;
    }
});

checkedCommentsForBlocked

Параметри

Име	Тип	Обавезно
tenantId	string	Да
commentIds	string	Да
sso	string	Не

Одговор

Враћа: CheckedCommentsForBlocked_200_response

Пример

Пример checkedCommentsForBlocked

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
utility::string_t commentIds = utility::conversions::to_string_t("cmt-456,cmt-789");
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("user@example.com");
auto task = api->checkedCommentsForBlocked(tenantId, commentIds, sso)
    .then([=](std::shared_ptr<CheckedCommentsForBlocked_200_response> resp) -> std::shared_ptr<CheckedCommentsForBlocked_200_response> {
        if (!resp) return std::make_shared<CheckedCommentsForBlocked_200_response>();
        return resp;
    });

blockUserFromComment

Параметри

Име	Тип	Обавезно
tenantId	string	Да
id	string	Да
blockFromCommentParams	BlockFromCommentParams	Да
userId	string	Не
anonUserId	string	Не

Одговор

Враћа: BlockFromCommentPublic_200_response

Пример

blockUserFromComment Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
auto blockParams = std::make_shared<BlockFromCommentParams>();
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<utility::string_t> anonUserId = boost::optional<utility::string_t>(U("anon-98765"));
api->blockUserFromComment(tenantId, commentId, *blockParams, userId, anonUserId)
.then([](std::shared_ptr<BlockFromCommentPublic_200_response> resp){
    if (resp) {
        std::cout << "User blocked successfully\n";
    } else {
        std::cout << "Block request returned empty response\n";
    }
}).wait();

createCommentPublic

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
urlId	string	Da
broadcastId	string	Da
commentData	CommentData	Da
sessionId	string	Ne
sso	string	Ne

Odgovor

Vraća: CreateCommentPublic_200_response

Primjer

Primjer createCommentPublic

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("/articles/2026/fastcomments-cpp-integration");
utility::string_t broadcastId = U("broadcast-001");
CommentData commentData;
commentData.content = U("Hello from the C++ SDK — great article!");
commentData.authorEmail = U("reader@example.com");
commentData.authorName = U("Jane Reader");
boost::optional<utility::string_t> sessionId = boost::optional<utility::string_t>(U("sess-9f3a2"));
boost::optional<utility::string_t> sso = boost::none;
auto task = api->createCommentPublic(tenantId, urlId, broadcastId, commentData, sessionId, sso)
    .then([](pplx::task<std::shared_ptr<CreateCommentPublic_200_response>> t) {
        try {
            auto resp = t.get();
            if (resp) {
                auto resultCopy = std::make_shared<CreateCommentPublic_200_response>(*resp);
            }
        } catch (const std::exception&) {}
    });
task.wait();

deleteComment

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
id	string	Da
contextUserId	string	Ne
isLive	bool	Ne

Odgovor

Vraća: DeleteComment_200_response

Primjer

Primjer deleteComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654321");
boost::optional<utility::string_t> contextUserId = boost::optional<utility::string_t>(U("moderator@acme.com"));
boost::optional<bool> isLive = boost::optional<bool>(true);
api->deleteComment(tenantId, commentId, contextUserId, isLive)
.then([](pplx::task<std::shared_ptr<DeleteComment_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto processed = std::make_shared<DeleteComment_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

deleteCommentPublic

Parametri

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

Odgovor

Vraća: DeleteCommentPublic_200_response

Primjer

deleteCommentPublic Primjer

Copy

utility::string_t tenantId(U("my-tenant-123"));
utility::string_t commentId(U("cmt-456"));
utility::string_t broadcastId(U("brd-789"));
boost::optional<utility::string_t> editKey = boost::optional<utility::string_t>(utility::string_t(U("editkey-abc123")));
boost::optional<utility::string_t> sso; 
api->deleteCommentPublic(tenantId, commentId, broadcastId, editKey, sso)
.then([](pplx::task<std::shared_ptr<DeleteCommentPublic_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto copied = std::make_shared<DeleteCommentPublic_200_response>(*resp);
            (void)copied;
        }
    } catch (const std::exception&) {
        auto fallback = std::make_shared<DeleteCommentPublic_200_response>();
        (void)fallback;
    }
});

deleteCommentVote

Parametri

Name	Type	Required
tenantId	string	Da
commentId	string	Da
voteId	string	Da
urlId	string	Da
broadcastId	string	Da
editKey	string	Ne
sso	string	Ne

Odgovor

Vraća: DeleteCommentVote_200_response

Primjer

deleteCommentVote Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-789");
utility::string_t voteId = U("vote-456");
utility::string_t urlId = U("/articles/2026/fastcomments-guide");
utility::string_t broadcastId = U("broadcast-001");
boost::optional<utility::string_t> editKey = boost::optional<utility::string_t>(U("editkey-abc"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
auto placeholder = std::make_shared<DeleteCommentVote_200_response>();
api->deleteCommentVote(tenantId, commentId, voteId, urlId, broadcastId, editKey, sso)
.then([=](pplx::task<std::shared_ptr<DeleteCommentVote_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) std::cout << "Vote deleted\n";
    } catch (const std::exception &e) {
        std::cerr << "Delete failed: " << e.what() << '\n';
    }
});

flagComment

Parametri

Name	Type	Required
tenantId	string	Da
id	string	Da
userId	string	Ne
anonUserId	string	Ne

Odgovor

Vraća: FlagComment_200_response

Primjer

Primjer flagComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
boost::optional<utility::string_t> userId{ utility::string_t(U("user@example.com")) };
boost::optional<utility::string_t> anonUserId;
api->flagComment(tenantId, commentId, userId, anonUserId)
.then([](std::shared_ptr<FlagComment_200_response> resp) {
    auto result = resp ? resp : std::make_shared<FlagComment_200_response>();
    (void)result;
});

getComment

Параметри

Назив	Тип	Обавезно	Опис
tenantId	string	Да
id	string	Да

Одговор

Враћа: GetComment_200_response

Пример

getComment Пример

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> maybeId = utility::conversions::to_string_t("comment-98765");
auto getTask = api->getComment(tenantId, *maybeId)
    .then([](pplx::task<std::shared_ptr<GetComment_200_response>> t) {
        try {
            auto resp = t.get();
            auto result = resp ? resp : std::make_shared<GetComment_200_response>();
            return result;
        } catch (const std::exception&) {
            return std::make_shared<GetComment_200_response>();
        }
    });

getComments

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
page	int32_t	Ne
limit	int32_t	Ne
skip	int32_t	Ne
asTree	bool	Ne
skipChildren	int32_t	Ne
limitChildren	int32_t	Ne
maxTreeDepth	int32_t	Ne
urlId	string	Ne
userId	string	Ne
anonUserId	string	Ne
contextUserId	string	Ne
hashTag	string	Ne
parentId	string	Ne
direction	SortDirections	Ne

Odgovor

Vraća: GetComments_200_response

Primjer

Primjer getComments

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<int32_t> page(1);
boost::optional<int32_t> limit(50);
boost::optional<int32_t> skip(0);
boost::optional<bool> asTree(true);
boost::optional<int32_t> skipChildren(0);
boost::optional<int32_t> limitChildren(10);
boost::optional<int32_t> maxTreeDepth(3);
boost::optional<utility::string_t> urlId(U("/articles/2025/fast-api"));
boost::optional<utility::string_t> userId(U("user@example.com"));
boost::optional<utility::string_t> anonUserId(U("anon-abc-123"));
boost::optional<utility::string_t> contextUserId(U("context-user-789"));
boost::optional<utility::string_t> hashTag(U("release"));
boost::optional<utility::string_t> parentId(U("parent-comment-456"));
boost::optional<SortDirections> direction(SortDirections::DESCENDING);
api->getComments(tenantId, page, limit, skip, asTree, skipChildren, limitChildren, maxTreeDepth, urlId, userId, anonUserId, contextUserId, hashTag, parentId, direction)
.then([](pplx::task<std::shared_ptr<GetComments_200_response>> task){
    try {
        auto response = task.get();
        if (!response) response = std::make_shared<GetComments_200_response>();
    } catch (const std::exception&) {
    }
});

getCommentsPublic

захтев tenantId urlId

Параметри

Име	Тип	Обавезно
tenantId	string	Да
urlId	string	Да
page	int32_t	Не
direction	SortDirections	Не
sso	string	Не
skip	int32_t	Не
skipChildren	int32_t	Не
limit	int32_t	Не
limitChildren	int32_t	Не
countChildren	bool	Не
fetchPageForCommentId	string	Не
includeConfig	bool	Не
countAll	bool	Не
includei10n	bool	Не
locale	string	Не
modules	string	Не
isCrawler	bool	Не
includeNotificationCount	bool	Не
asTree	bool	Не
maxTreeDepth	int32_t	Не
useFullTranslationIds	bool	Не
parentId	string	Не
searchText	string	Не
hashTags	vector<string	Не
userId	string	Не
customConfigStr	string	Не
afterCommentId	string	Не
beforeCommentId	string	Не

Одговор

Враћа: GetCommentsPublic_200_response

Пример

getCommentsPublic Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("article-2026-01-12");
boost::optional<int32_t> page(2);
boost::optional<SortDirections> direction(SortDirections::DESC);
boost::optional<bool> includeConfig(true);
boost::optional<std::vector<utility::string_t>> hashTags(std::vector<utility::string_t>{ U("feature"), U("bug") });
api->getCommentsPublic(
    tenantId,
    urlId,
    page,
    direction,
    boost::optional<utility::string_t>(),
    boost::optional<int32_t>(),
    boost::optional<int32_t>(),
    boost::optional<int32_t>(50),
    boost::optional<int32_t>(),
    boost::optional<bool>(false),
    boost::optional<utility::string_t>(),
    includeConfig,
    boost::optional<bool>(),
    boost::optional<bool>(),
    boost::optional<utility::string_t>(),
    boost::optional<utility::string_t>(),
    boost::optional<bool>(),
    boost::optional<bool>(),
    boost::optional<bool>(),
    boost::optional<int32_t>(),
    boost::optional<bool>(),
    boost::optional<utility::string_t>(),
    boost::optional<utility::string_t>(),
    hashTags,
    boost::optional<utility::string_t>(U("user-789")),
    boost::optional<utility::string_t>(),
    boost::optional<utility::string_t>()
).then([](pplx::task<std::shared_ptr<GetCommentsPublic_200_response>> t){
    try {
        auto resp = t.get();
        auto fallback = std::make_shared<GetCommentsPublic_200_response>();
        (void)(resp ? resp : fallback);
    } catch (...) {}
});

getCommentText

Parametri

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

Odgovor

Vraća: GetCommentText_200_response

Primjer

Primjer getCommentText

Copy

utility::string_t tenantId(U("my-tenant-123"));
utility::string_t commentId(U("cmt-456"));
boost::optional<utility::string_t> editKey(utility::string_t(U("edit-key-789")));
boost::optional<utility::string_t> sso(utility::string_t(U("user@example.com")));
auto task = api->getCommentText(tenantId, commentId, editKey, sso)
    .then([](std::shared_ptr<GetCommentText_200_response> resp){
        if (resp) {
            std::cout << "Comment text retrieved\n";
        } else {
            std::cout << "Comment not found\n";
        }
    });
task.wait();

getCommentVoteUserNames

Параметри

Име	Тип	Обавезно
tenantId	string	Да
commentId	string	Да
dir	int32_t	Да
sso	string	Не

Одговор

Враћа: GetCommentVoteUserNames_200_response

Пример

getCommentVoteUserNames Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456");
int32_t dir = 1;
boost::optional<utility::string_t> sso{ utility::string_t(U("user@example.com")) };
api->getCommentVoteUserNames(tenantId, commentId, dir, sso)
    .then([](pplx::task<std::shared_ptr<GetCommentVoteUserNames_200_response>> t) {
        try {
            auto resp = t.get();
            if (!resp) resp = std::make_shared<GetCommentVoteUserNames_200_response>();
        } catch (const std::exception&) {
        }
    });

lockComment

Parametri

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

Odgovor

Vraća: LockComment_200_response

Primjer

Primjer lockComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456");
utility::string_t broadcastId = U("brdcst-789");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
api->lockComment(tenantId, commentId, broadcastId, sso)
    .then([](pplx::task<std::shared_ptr<LockComment_200_response>> t)
    {
        try
        {
            auto resp = t.get();
            if(!resp)
            {
                resp = std::make_shared<LockComment_200_response>();
            }
        }
        catch(const std::exception& ex)
        {
            (void)ex;
        }
    });

pinComment

Parametri

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

Odgovor

Vraća: PinComment_200_response

Primjer

pinComment Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
utility::string_t broadcastId = U("broadcast-98765");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
api->pinComment(tenantId, commentId, broadcastId, sso)
.then([](pplx::task<std::shared_ptr<PinComment_200_response>> t){
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<PinComment_200_response>();
        (void)resp;
    } catch (...) {}
}).wait();

saveComment

Параметри

Име	Тип	Обавезно
tenantId	string	Да
createCommentParams	CreateCommentParams	Да
isLive	bool	Не
doSpamCheck	bool	Не
sendEmails	bool	Не
populateNotifications	bool	Не

Одговор

Враћа: SaveComment_200_response

Пример

saveComment Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
auto createParamsPtr = std::make_shared<CreateCommentParams>();
createParamsPtr->content = utility::string_t(U("This is a test comment posted via SDK"));
createParamsPtr->authorEmail = utility::string_t(U("user@example.com"));
createParamsPtr->threadId = utility::string_t(U("thread-456"));
boost::optional<bool> isLive(true);
boost::optional<bool> doSpamCheck(false);
boost::optional<bool> sendEmails(true);
boost::optional<bool> populateNotifications(false);
auto task = api->saveComment(tenantId, *createParamsPtr, isLive, doSpamCheck, sendEmails, populateNotifications)
.then([](std::shared_ptr<SaveComment_200_response> resp){
    if (resp) std::cout << "Comment saved successfully\n";
    else std::cout << "Failed to save comment\n";
});
task.wait();

setCommentText

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
commentId	string	Da
broadcastId	string	Da
commentTextUpdateRequest	CommentTextUpdateRequest	Da
editKey	string	Ne
sso	string	Ne

Odgovor

Vraća: SetCommentText_200_response

Primjer

Primjer setCommentText

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456");
utility::string_t broadcastId = U("bcast-789");
CommentTextUpdateRequest commentTextUpdateRequest;
commentTextUpdateRequest.setText(U("Updated comment text by moderator."));
boost::optional<utility::string_t> editKey = boost::optional<utility::string_t>(U("edit-key-abc123"));
boost::optional<utility::string_t> sso;
api->setCommentText(tenantId, commentId, broadcastId, commentTextUpdateRequest, editKey, sso)
.then([](pplx::task<std::shared_ptr<SetCommentText_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto result = std::make_shared<SetCommentText_200_response>(*resp);
            std::cout << "Comment updated\n";
        } else {
            std::cout << "No response\n";
        }
    } catch (const std::exception &e) {
        std::cerr << "setCommentText error: " << e.what() << '\n';
    }
});

unBlockUserFromComment

Parametri

Name	Type	Required
tenantId	string	Da
id	string	Da
unBlockFromCommentParams	UnBlockFromCommentParams	Da
userId	string	Ne
anonUserId	string	Ne

Odgovor

Vraća: UnBlockCommentPublic_200_response

Primjer

Primjer unBlockUserFromComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
auto paramsPtr = std::make_shared<UnBlockFromCommentParams>();
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<utility::string_t> anonUserId = boost::none;
api->unBlockUserFromComment(tenantId, commentId, *paramsPtr, userId, anonUserId)
    .then([](std::shared_ptr<UnBlockCommentPublic_200_response> resp){
        (void)resp;
    })
    .wait();

unFlagComment

Параметри

Име	Тип	Обавезно
tenantId	string	Да
id	string	Да
userId	string	Не
anonUserId	string	Не

Одговор

Враћа: FlagComment_200_response

Пример

unFlagComment Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654321");
boost::optional<utility::string_t> userId(U("user@example.com"));
boost::optional<utility::string_t> anonUserId;
auto fallback = std::make_shared<FlagComment_200_response>();
api->unFlagComment(tenantId, commentId, userId, anonUserId)
    .then([fallback](pplx::task<std::shared_ptr<FlagComment_200_response>> t) {
        try {
            auto resp = t.get();
            if (!resp) resp = fallback;
        } catch (...) {
        }
    });

unLockComment

Parametri

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

Odgovor

Vraća: LockComment_200_response

Primjer

Primjer unLockComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654");
utility::string_t broadcastId = U("brd-456");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
auto dummyResp = std::make_shared<LockComment_200_response>();
api->unLockComment(tenantId, commentId, broadcastId, sso)
.then([](pplx::task<std::shared_ptr<LockComment_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            std::cout << "Comment unlocked successfully\n";
        } else {
            std::cout << "Unlock returned empty response\n";
        }
    } catch (const std::exception& e) {
        std::cerr << "Error unlocking comment: " << e.what() << '\n';
    }
});

unPinComment

Параметри

Name	Type	Required
tenantId	string	Да
commentId	string	Да
broadcastId	string	Да
sso	string	Не

Одговор

Враћа: PinComment_200_response

Пример

Пример unPinComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
utility::string_t broadcastId = U("brd-98765");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
auto defaultResp = std::make_shared<PinComment_200_response>();
api->unPinComment(tenantId, commentId, broadcastId, sso)
.then([defaultResp](pplx::task<std::shared_ptr<PinComment_200_response>> task) {
    try {
        auto resp = task.get();
        if (!resp) resp = defaultResp;
        std::cout << "unPinComment completed; response pointer " << (resp ? "valid" : "null") << std::endl;
    } catch (const std::exception &e) {
        std::cerr << "unPinComment failed: " << e.what() << std::endl;
    }
});

updateComment

Параметри

Name	Type	Required
tenantId	string	Да
id	string	Да
updatableCommentParams	UpdatableCommentParams	Да
contextUserId	string	Не
doSpamCheck	bool	Не
isLive	bool	Не

Одговор

Враћа: FlagCommentPublic_200_response

Пример

Пример за updateComment

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto commentId = utility::string_t(U("comment-456"));
auto body = std::make_shared<UpdatableCommentParams>();
body->content = utility::string_t(U("Updated comment text: fixed a typo and clarified meaning."));
boost::optional<utility::string_t> contextUserId(utility::string_t(U("user@example.com")));
boost::optional<bool> doSpamCheck(true);
boost::optional<bool> isLive(false);
api->updateComment(tenantId, commentId, body, contextUserId, doSpamCheck, isLive)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
    try {
        auto result = t.get();
        (void)result;
    } catch (...) {}
});

voteComment

Параметри

Име	Тип	Обавезно
tenantId	string	Да
commentId	string	Да
urlId	string	Да
broadcastId	string	Да
voteBodyParams	VoteBodyParams	Да
sessionId	string	Не
sso	string	Не

Одговор

Враћа: VoteComment_200_response

Пример

voteComment Пример

Copy

VoteBodyParams voteBodyParams;
utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-7890");
utility::string_t urlId = U("/articles/2025/how-to-cpprest");
utility::string_t broadcastId = U("broadcast-321");
boost::optional<utility::string_t> sessionId = boost::optional<utility::string_t>(U("sess-0a1b2c"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-jwt-xyz"));
api->voteComment(tenantId, commentId, urlId, broadcastId, voteBodyParams, sessionId, sso)
    .then([](pplx::task<std::shared_ptr<VoteComment_200_response>> t) {
        try {
            auto resp = t.get();
            if (!resp) resp = std::make_shared<VoteComment_200_response>();
        } catch (...) {
        }
    });

addDomainConfig

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Da
addDomainConfigParams	AddDomainConfigParams	Da

Odgovor

Vraća: AddDomainConfig_200_response

Primjer

Primjer addDomainConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
AddDomainConfigParams params;
params.domain = U("comments.example.com");
params.allowSubdomains = boost::optional<bool>(true);
params.contactEmail = boost::optional<utility::string_t>(U("admin@example.com"));
api->addDomainConfig(tenantId, params)
.then([](pplx::task<std::shared_ptr<AddDomainConfig_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<AddDomainConfig_200_response>(*resp);
            (void)copy;
        }
    } catch (const std::exception& e) {
        (void)e;
    }
});

deleteDomainConfig

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Da
domain	string	Da

Odgovor

Vraća: DeleteDomainConfig_200_response

Primjer

Primjer deleteDomainConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domain = U("comments.example.com");
boost::optional<utility::string_t> ifMatch = boost::optional<utility::string_t>(U("W/\"abc123\""));
api->deleteDomainConfig(tenantId, domain)
.then([](pplx::task<std::shared_ptr<DeleteDomainConfig_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            auto resultCopy = std::make_shared<DeleteDomainConfig_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

getDomainConfig

Параметри

Име	Тип	Обавезно	Опис
tenantId	string	Да
domain	string	Да

Одговор

Враћа: GetDomainConfig_200_response

Пример

getDomainConfig Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domain = U("example.com");
boost::optional<utility::string_t> env = boost::optional<utility::string_t>(U("production"));
api->getDomainConfig(tenantId, domain).then([=](pplx::task<std::shared_ptr<GetDomainConfig_200_response>> t) {
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<GetDomainConfig_200_response>();
        std::cout << "Domain config received for " << utility::conversions::to_utf8string(domain) << '\n';
    } catch (const std::exception &ex) {
        std::cerr << "Failed to get domain config: " << ex.what() << '\n';
    }
});

getDomainConfigs

Параметри

Назив	Тип	Обавезно	Опис
tenantId	string	Да

Одговор

Враћа: GetDomainConfigs_200_response

Пример

getDomainConfigs Пример

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> requestId = utility::conversions::to_string_t("req-789");
api->getDomainConfigs(tenantId)
    .then([requestId](pplx::task<std::shared_ptr<GetDomainConfigs_200_response>> t){
        try {
            auto resp = t.get();
            auto copy = std::make_shared<GetDomainConfigs_200_response>(*resp);
            if (requestId) std::cout << "Request id present\n";
            std::cout << "Domain configs loaded\n";
        } catch (const std::exception &e) {
            std::cerr << "Error: " << e.what() << '\n';
        }
    }).wait();

patchDomainConfig

Параметри

Име	Тип	Обавезно
tenantId	string	Да
domainToUpdate	string	Да
patchDomainConfigParams	PatchDomainConfigParams	Да

Одговор

Враћа: GetDomainConfig_200_response

Пример

patchDomainConfig Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domainToUpdate = U("example.com");
PatchDomainConfigParams params;
params.adminEmail = boost::optional<utility::string_t>(U("admin@example.com"));
params.enableSso = boost::optional<bool>(true);
params.ssoRedirectUrl = boost::optional<utility::string_t>(U("https://auth.example.com/callback"));
api->patchDomainConfig(tenantId, domainToUpdate, params)
    .then([](pplx::task<std::shared_ptr<GetDomainConfig_200_response>> task){
        try {
            auto resp = task.get();
            if (resp) {
                auto updated = std::make_shared<GetDomainConfig_200_response>(*resp);
            }
        } catch (const std::exception& e) {
            auto err = std::string(e.what());
        }
    });

putDomainConfig

Parametri

Name	Type	Required
tenantId	string	Da
domainToUpdate	string	Da
updateDomainConfigParams	UpdateDomainConfigParams	Da

Odgovor

Vraća: GetDomainConfig_200_response

Primjer

Primjer putDomainConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domainToUpdate = U("comments.myapp.com");
auto params = std::make_shared<UpdateDomainConfigParams>();
params->displayName = utility::string_t(U("My App Comments"));
params->enabled = boost::optional<bool>(true);
params->contactEmail = boost::optional<utility::string_t>(U("admin@myapp.com"));
api->putDomainConfig(tenantId, domainToUpdate, *params)
.then([](pplx::task<std::shared_ptr<GetDomainConfig_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto updated = resp;
        }
    } catch (const std::exception& e) {
    }
});

createEmailTemplate

Параметри

Name	Type	Required	Description
tenantId	string	Да
createEmailTemplateBody	CreateEmailTemplateBody	Да

Одговор

Враћа: CreateEmailTemplate_200_response

Пример

Пример createEmailTemplate

Copy

utility::string_t tenantId = U("my-tenant-123");
auto body = std::make_shared<CreateEmailTemplateBody>();
body->name = utility::string_t(U("Welcome Email"));
body->subject = utility::string_t(U("Welcome to Our Service"));
body->fromEmail = utility::string_t(U("no-reply@mycompany.com"));
body->fromName = utility::string_t(U("MyCompany Support"));
body->html = utility::string_t(U("<p>Hello {{user.name}}, welcome to MyCompany.</p>"));
body->description = boost::optional<utility::string_t>(utility::string_t(U("Onboarding welcome template")));
api->createEmailTemplate(tenantId, *body)
.then([](pplx::task<std::shared_ptr<CreateEmailTemplate_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            bool created = true;
            (void)created;
        }
    } catch (const std::exception&) {
    }
});

deleteEmailTemplate

Параметри

Име	Тип	Обавезно	Опис
tenantId	string	Да
id	string	Да

Одговор

Враћа: FlagCommentPublic_200_response

Пример

deleteEmailTemplate Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email-template-456");
boost::optional<utility::string_t> requestNote = boost::optional<utility::string_t>(U("remove-obsolete"));
auto fallback = std::make_shared<FlagCommentPublic_200_response>();
api->deleteEmailTemplate(tenantId, templateId)
.then([requestNote, fallback](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) -> pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> {
    try {
        auto resp = t.get();
        if (resp) return pplx::task_from_result(resp);
        if (requestNote) return pplx::task_from_result(fallback);
        return pplx::task_from_result<std::shared_ptr<FlagCommentPublic_200_response>>(nullptr);
    } catch (...) {
        return pplx::task_from_result<std::shared_ptr<FlagCommentPublic_200_response>>(nullptr);
    }
});

deleteEmailTemplateRenderError

Параметри

Име	Тип	Обавезно
tenantId	string	Да
id	string	Да
errorId	string	Да

Одговор

Враћа: FlagCommentPublic_200_response

Пример

deleteEmailTemplateRenderError Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email-template-456");
utility::string_t errorId = U("render-error-789");
auto placeholder = std::make_shared<FlagCommentPublic_200_response>();
boost::optional<utility::string_t> operatorNote = boost::none;
operatorNote = U("auto-resolved");
api->deleteEmailTemplateRenderError(tenantId, templateId, errorId)
    .then([operatorNote, templateId](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> previous) {
        try {
            auto resp = previous.get();
            if (resp) {
                std::cout << "Successfully deleted render error for template: " << utility::conversions::to_utf8string(templateId) << std::endl;
            }
            if (operatorNote) {
                std::cout << "Note: " << utility::conversions::to_utf8string(operatorNote.value()) << std::endl;
            }
        } catch (const std::exception &e) {
            std::cerr << "API error: " << e.what() << std::endl;
        }
    });

getEmailTemplate

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: GetEmailTemplate_200_response

Primjer

Primjer getEmailTemplate

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email-001");
boost::optional<utility::string_t> preferLocale = boost::optional<utility::string_t>(U("en-US"));
api->getEmailTemplate(tenantId, templateId)
    .then([preferLocale](std::shared_ptr<GetEmailTemplate_200_response> resp) {
        auto templateResp = resp ? resp : std::make_shared<GetEmailTemplate_200_response>();
        if (preferLocale) {
            (void)preferLocale;
        }
        return templateResp;
    });

getEmailTemplateDefinitions

Параметри

Назив	Тип	Обавезно	Опис
tenantId	string	Да

Одговор

Враћа: GetEmailTemplateDefinitions_200_response

Пример

getEmailTemplateDefinitions Пример

Copy

boost::optional<utility::string_t> tenantIdOpt = utility::string_t(U("my-tenant-123"));
api->getEmailTemplateDefinitions(tenantIdOpt.value())
.then([](pplx::task<std::shared_ptr<GetEmailTemplateDefinitions_200_response>> task) {
    try {
        auto resp = task.get();
        auto localCopy = std::make_shared<GetEmailTemplateDefinitions_200_response>(*resp);
        (void)localCopy;
    } catch (const std::exception& e) {
        auto fallback = std::make_shared<GetEmailTemplateDefinitions_200_response>();
        (void)fallback;
    }
});

getEmailTemplateRenderErrors

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
id	string	Da
skip	double	Ne

Odgovor

Vraća: GetEmailTemplateRenderErrors_200_response

Primjer

getEmailTemplateRenderErrors Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("email-template-789");
boost::optional<double> skip{10.0};
auto defaultResp = std::make_shared<GetEmailTemplateRenderErrors_200_response>();
api->getEmailTemplateRenderErrors(tenantId, id, skip).then([defaultResp](pplx::task<std::shared_ptr<GetEmailTemplateRenderErrors_200_response>> t){
    try {
        auto resp = t.get();
        if(!resp) resp = defaultResp;
        std::wcout << (resp ? U("Received render errors response\n") : U("No response\n"));
    } catch(...) {
        std::wcout << U("Failed to retrieve render errors\n");
    }
});

getEmailTemplates

Параметри

Име	Тип	Обавезно	Опис
tenantId	string	Да
skip	double	Не

Одговор

Враћа: GetEmailTemplates_200_response

Пример

getEmailTemplates Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = 10.0;
api->getEmailTemplates(tenantId, skip).then([](pplx::task<std::shared_ptr<GetEmailTemplates_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<GetEmailTemplates_200_response>(*resp);
        }
    } catch (const std::exception& e) {
        (void)e;
    }
});

renderEmailTemplate

Параметри

Име	Тип	Обавезно
tenantId	string	Да
renderEmailTemplateBody	RenderEmailTemplateBody	Да
locale	string	Не

Одговор

Враћа: RenderEmailTemplate_200_response

Примјер

renderEmailTemplate Примјер

Copy

utility::string_t tenantId = U("my-tenant-123");
RenderEmailTemplateBody renderEmailTemplateBody;
renderEmailTemplateBody.setTemplateName(U("welcome_wagon"));
renderEmailTemplateBody.setRecipient(U("alice@example.com"));
web::json::value vars;
vars[U("firstName")] = web::json::value::string(U("Alice"));
renderEmailTemplateBody.setVariables(vars);
boost::optional<utility::string_t> locale = boost::optional<utility::string_t>(U("en-US"));
auto placeholder = std::make_shared<RenderEmailTemplate_200_response>();
api->renderEmailTemplate(tenantId, renderEmailTemplateBody, locale)
.then([](pplx::task<std::shared_ptr<RenderEmailTemplate_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            std::cout << "Email template rendered successfully" << std::endl;
        } else {
            std::cerr << "No response returned" << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << "Render failed: " << e.what() << std::endl;
    }
});

updateEmailTemplate

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
id	string	Da
updateEmailTemplateBody	UpdateEmailTemplateBody	Da

Odgovor

Vraća: FlagCommentPublic_200_response

Primjer

Primjer updateEmailTemplate

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email-01");
UpdateEmailTemplateBody updateBody;
boost::optional<utility::string_t> optionalFrom = boost::optional<utility::string_t>(U("no-reply@myapp.com"));
updateBody.from = optionalFrom;
updateBody.subject = U("Welcome to MyApp");
updateBody.html = U("<p>Hi {{displayName}}, welcome to MyApp!</p>");
auto bodyPtr = std::make_shared<UpdateEmailTemplateBody>(updateBody);
api->updateEmailTemplate(tenantId, templateId, *bodyPtr)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            std::cout << "Email template updated successfully\n";
        } else {
            std::cout << "Unexpected empty response\n";
        }
    } catch (const std::exception &e) {
        std::cerr << "Update failed: " << e.what() << '\n';
    }
});

getEventLog

req tenantId urlId userIdWS

Parametri

Name	Type	Required
tenantId	string	Da
urlId	string	Da
userIdWS	string	Da
startTime	int64_t	Da
endTime	int64_t	Da

Odgovor

Vraća: GetEventLog_200_response

Primjer

getEventLog Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("article-456");
utility::string_t userIdWS = U("user@example.com");
int64_t startTime = 1672531200LL;
boost::optional<int64_t> endTimeOpt = 1672617600LL;
api->getEventLog(tenantId, urlId, userIdWS, startTime, *endTimeOpt)
    .then([](pplx::task<std::shared_ptr<GetEventLog_200_response>> t){
        try {
            auto resp = t.get();
            if (!resp) resp = std::make_shared<GetEventLog_200_response>();
        } catch (const std::exception&) {}
    });

getGlobalEventLog

obavezno tenantId urlId userIdWS

Parametri

Name	Type	Required
tenantId	string	Da
urlId	string	Da
userIdWS	string	Da
startTime	int64_t	Da
endTime	int64_t	Da

Odgovor

Vraća: GetEventLog_200_response

Primjer

Primjer getGlobalEventLog

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t defaultUrlId = U("article-456");
boost::optional<utility::string_t> maybeUrlId = boost::optional<utility::string_t>(U("article-456"));
utility::string_t urlId = maybeUrlId ? *maybeUrlId : defaultUrlId;
utility::string_t userIdWS = U("user@example.com");
int64_t startTime = 1622505600000LL;
int64_t endTime = 1622592000000LL;
auto defaultResp = std::make_shared<GetEventLog_200_response>();
api->getGlobalEventLog(tenantId, urlId, userIdWS, startTime, endTime)
.then([](pplx::task<std::shared_ptr<GetEventLog_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) std::cout << "Received event log with entries\n";
        else std::cout << "No event log returned\n";
    } catch (const std::exception &e) {
        std::cerr << "getGlobalEventLog failed: " << e.what() << '\n';
    }
});

createFeedPost

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
createFeedPostParams	CreateFeedPostParams	Da
broadcastId	string	Ne
isLive	bool	Ne
doSpamCheck	bool	Ne
skipDupCheck	bool	Ne

Odgovor

Vraća: CreateFeedPost_200_response

Primjer

Primjer createFeedPost

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateFeedPostParams params;
params.title = utility::string_t(U("Weekly Product Update"));
params.content = utility::string_t(U("This week we shipped several improvements to the API."));
params.authorEmail = utility::string_t(U("jane.doe@example.com"));
boost::optional<utility::string_t> broadcastId = boost::optional<utility::string_t>(U("broadcast-456"));
boost::optional<bool> isLive = boost::optional<bool>(true);
boost::optional<bool> doSpamCheck = boost::optional<bool>(false);
boost::optional<bool> skipDupCheck = boost::optional<bool>(false);
api->createFeedPost(tenantId, params, broadcastId, isLive, doSpamCheck, skipDupCheck)
.then([](pplx::task<std::shared_ptr<CreateFeedPost_200_response>> t){
    try {
        auto resp = t.get();
        auto copy = std::make_shared<CreateFeedPost_200_response>(*resp);
    } catch (...) {}
});

createFeedPostPublic

Параметри

Назив	Тип	Обавезно
tenantId	string	Да
createFeedPostParams	CreateFeedPostParams	Да
broadcastId	string	Не
sso	string	Не

Одговор

Враћа: CreateFeedPostPublic_200_response

Пример

createFeedPostPublic Пример

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto paramsPtr = std::make_shared<CreateFeedPostParams>();
paramsPtr->title = utility::string_t(U("Weekly Release Notes"));
paramsPtr->content = utility::string_t(U("We've deployed version 2.4.1 with bug fixes and UX improvements."));
paramsPtr->authorEmail = utility::string_t(U("alice@example.com"));
boost::optional<utility::string_t> broadcastId = utility::string_t(U("broadcast-456"));
boost::optional<utility::string_t> sso = utility::string_t(U("sso-token-abc123"));
api->createFeedPostPublic(tenantId, *paramsPtr, broadcastId, sso)
    .then([](pplx::task<std::shared_ptr<CreateFeedPostPublic_200_response>> t) {
        try {
            auto resp = t.get();
            if (resp) std::cout << "Feed post created successfully\n";
        } catch (const std::exception& e) {
            std::cerr << "Failed to create feed post: " << e.what() << '\n';
        }
    });

deleteFeedPostPublic

Параметри

Име	Тип	Обавезно
tenantId	string	Да
postId	string	Да
broadcastId	string	Не
sso	string	Не

Одговор

Враћа: DeleteFeedPostPublic_200_response

Пример

deleteFeedPostPublic Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t postId = U("post-456");
boost::optional<utility::string_t> broadcastId = boost::optional<utility::string_t>(U("broadcast-789"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
api->deleteFeedPostPublic(tenantId, postId, broadcastId, sso)
.then([](pplx::task<std::shared_ptr<DeleteFeedPostPublic_200_response>> t){
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<DeleteFeedPostPublic_200_response>();
        (void)resp;
    } catch (const std::exception&) {
    }
});

getFeedPosts

Параметри

Назив	Тип	Обавезно
tenantId	string	Да
afterId	string	Не
limit	int32_t	Не
tags	vector<string	Не

Одговор

Враћа: GetFeedPosts_200_response

Примјер

getFeedPosts Примјер

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> afterId(utility::string_t(U("post_456")));
boost::optional<int32_t> limit(50);
std::vector<utility::string_t> tagVec{U("news"), U("announcement")};
boost::optional<std::vector<utility::string_t>> tags(tagVec);
api->getFeedPosts(tenantId, afterId, limit, tags)
.then([](std::shared_ptr<GetFeedPosts_200_response> resp) {
    auto copy = std::make_shared<GetFeedPosts_200_response>(*resp);
    (void)copy;
});

getFeedPostsPublic

req tenantId afterId

Parametri

Name	Type	Required
tenantId	string	Da
afterId	string	Ne
limit	int32_t	Ne
tags	vector<string	Ne
sso	string	Ne
isCrawler	bool	Ne
includeUserInfo	bool	Ne

Odgovor

Vraća: GetFeedPostsPublic_200_response

Primjer

Primjer getFeedPostsPublic

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> afterId = boost::optional<utility::string_t>(U("post_abc123"));
boost::optional<int32_t> limit = boost::optional<int32_t>(20);
boost::optional<std::vector<utility::string_t>> tags = boost::optional<std::vector<utility::string_t>>(std::vector<utility::string_t>{U("news"), U("tech")});
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<bool> isCrawler = boost::optional<bool>(false);
boost::optional<bool> includeUserInfo = boost::optional<bool>(true);
api->getFeedPostsPublic(tenantId, afterId, limit, tags, sso, isCrawler, includeUserInfo)
.then([](pplx::task<std::shared_ptr<GetFeedPostsPublic_200_response>> t){
    try {
        std::shared_ptr<GetFeedPostsPublic_200_response> resp = t.get();
        auto marker = std::make_shared<int>(1);
        if (resp) { (void)marker; }
    } catch (const std::exception&) {
    }
});

getFeedPostsStats

Параметри

Име	Тип	Обавезно
tenantId	string	Да
postIds	vector<string	Да
sso	string	Не

Одговор

Враћа: GetFeedPostsStats_200_response

Пример

getFeedPostsStats Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
std::vector<utility::string_t> postIds{ U("post-abc-001"), U("post-xyz-123") };
boost::optional<utility::string_t> sso(U("user@example.com"));
api->getFeedPostsStats(tenantId, postIds, sso)
    .then([](pplx::task<std::shared_ptr<GetFeedPostsStats_200_response>> t)
    {
        try {
            auto resp = t.get();
            auto respCopy = resp ? std::make_shared<GetFeedPostsStats_200_response>(*resp) : nullptr;
            (void)respCopy;
        } catch (const std::exception&) {}
    });

getUserReactsPublic

Параметри

Име	Тип	Обавезно
tenantId	string	Да
postIds	vector<string	Не
sso	string	Не

Одговор

Враћа: GetUserReactsPublic_200_response

Пример

getUserReactsPublic Пример

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
std::vector<utility::string_t> postIdsVec = {
    utility::conversions::to_string_t("post-456"),
    utility::conversions::to_string_t("post-789")
};
boost::optional<std::vector<utility::string_t>> postIdsOpt = postIdsVec;
boost::optional<utility::string_t> ssoOpt = utility::conversions::to_string_t("user@example.com");
api->getUserReactsPublic(tenantId, postIdsOpt, ssoOpt)
    .then([](pplx::task<std::shared_ptr<GetUserReactsPublic_200_response>> t) {
        try {
            auto resp = t.get();
            if (!resp) resp = std::make_shared<GetUserReactsPublic_200_response>();
        } catch (const std::exception&) {
        }
    });

reactFeedPostPublic

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
postId	string	Da
reactBodyParams	ReactBodyParams	Da
isUndo	bool	Ne
broadcastId	string	Ne
sso	string	Ne

Odgovor

Vraća: ReactFeedPostPublic_200_response

Primjer

reactFeedPostPublic Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t postId = U("post-987");
ReactBodyParams reactBodyParams;
reactBodyParams.userId = U("jane.doe@example.com");
reactBodyParams.reaction = U("like");
boost::optional<bool> isUndo = boost::optional<bool>(false);
boost::optional<utility::string_t> broadcastId = boost::optional<utility::string_t>(U("broadcast-001"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-token-xyz"));
api->reactFeedPostPublic(tenantId, postId, reactBodyParams, isUndo, broadcastId, sso)
    .then([](pplx::task<std::shared_ptr<ReactFeedPostPublic_200_response>> task) {
        try {
            auto resp = task.get();
            auto out = resp ? resp : std::make_shared<ReactFeedPostPublic_200_response>();
            std::cout << "Reaction processed\n";
        } catch (const std::exception &e) {
            std::cerr << "React failed: " << e.what() << '\n';
        }
    });

updateFeedPost

Parametri

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

Odgovor

Vraća: FlagCommentPublic_200_response

Primjer

Primjer updateFeedPost

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t postId = U("post-987654321");
FeedPost feedPost;
feedPost.title = U("Weekly status update");
feedPost.content = U("Completed the migration of the comments service to the new infra.");
feedPost.authorEmail = U("developer@acme-corp.com");
boost::optional<utility::string_t> summary = boost::optional<utility::string_t>(U("Migration complete"));
feedPost.summary = summary;
auto updateTask = api->updateFeedPost(tenantId, postId, feedPost)
    .then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
        try {
            auto resp = t.get();
            if (resp) {
                auto cloned = std::make_shared<FlagCommentPublic_200_response>(*resp);
            }
        } catch (...) {
        }
    });

updateFeedPostPublic

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
postId	string	Da
updateFeedPostParams	UpdateFeedPostParams	Da
broadcastId	string	Ne
sso	string	Ne

Odgovor

Vraća: CreateFeedPostPublic_200_response

Primjer

updateFeedPostPublic Primjer

Copy

utility::string_t tenantId = U"my-tenant-123";
utility::string_t postId = U"post-456";
UpdateFeedPostParams params;
boost::optional<utility::string_t> broadcastId = utility::string_t(U"broadcast-789");
boost::optional<utility::string_t> sso = utility::string_t(U"user@example.com");
api->updateFeedPostPublic(tenantId, postId, params, broadcastId, sso)
.then([](pplx::task<std::shared_ptr<CreateFeedPostPublic_200_response>> task){
    try {
        auto resp = task.get();
        if (!resp) resp = std::make_shared<CreateFeedPostPublic_200_response>();
        (void)resp;
    } catch (...) {}
});

flagCommentPublic

Параметри

Име	Тип	Обавезно
tenantId	string	Да
commentId	string	Да
isFlagged	bool	Да
sso	string	Не

Одговор

Враћа: FlagCommentPublic_200_response

Пример

Пример flagCommentPublic

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-789012");
bool isFlagged = true;
boost::optional<utility::string_t> sso{ U("user@example.com") };
api->flagCommentPublic(tenantId, commentId, isFlagged, sso)
.then([](std::shared_ptr<FlagCommentPublic_200_response> resp){
    auto respCopy = std::make_shared<FlagCommentPublic_200_response>(*resp);
    return respCopy;
});

addHashTag

Параметри

Име	Тип	Обавезно	Опис
tenantId	string	Не
createHashTagBody	CreateHashTagBody	Не

Одговор

Враћа: AddHashTag_200_response

Пример

addHashTag Пример

Copy

boost::optional<utility::string_t> tenantId(U("my-tenant-123"));
auto bodyPtr = std::make_shared<CreateHashTagBody>();
bodyPtr->name = U("release");
bodyPtr->color = U("#00aaff");
boost::optional<CreateHashTagBody> createBody(*bodyPtr);
api->addHashTag(tenantId, createBody).then([](pplx::task<std::shared_ptr<AddHashTag_200_response>> t){
    try {
        auto resp = t.get();
        (void)resp;
    } catch(...) {}
});

addHashTagsBulk

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Ne
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Ne

Odgovor

Vraća: AddHashTagsBulk_200_response

Primjer

Primjer addHashTagsBulk

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
auto bodyPtr = std::make_shared<BulkCreateHashTagsBody>();
boost::optional<utility::string_t> optTenant(tenantId);
boost::optional<BulkCreateHashTagsBody> optBody(*bodyPtr);
api->addHashTagsBulk(optTenant, optBody).then([](pplx::task<std::shared_ptr<AddHashTagsBulk_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) std::cout << "Bulk hashtags added for tenant\n";
    } catch (const std::exception &e) {
        std::cerr << "addHashTagsBulk error: " << e.what() << '\n';
    }
});

deleteHashTag

Параметри

Назив	Тип	Обавезно
tag	string	Да
tenantId	string	Не
deleteHashTagRequest	DeleteHashTag_request	Не

Одговор

Враћа: FlagCommentPublic_200_response

Пример

deleteHashTag Пример

Copy

utility::string_t tag = U("inappropriate");
boost::optional<utility::string_t> tenantId = boost::optional<utility::string_t>(U("my-tenant-123"));
DeleteHashTag_request req;
boost::optional<DeleteHashTag_request> optReq = boost::optional<DeleteHashTag_request>(req);
api->deleteHashTag(tag, tenantId, optReq)
.then([](std::shared_ptr<FlagCommentPublic_200_response> resp){
    auto out = std::make_shared<FlagCommentPublic_200_response>(*resp);
    std::cout << "Hashtag removed successfully for tenant\n";
    return out;
}).wait();

getHashTags

Параметри

Име	Тип	Обавезно	Опис
tenantId	string	Да
page	double	Не

Одговор

Враћа: GetHashTags_200_response

Пример

getHashTags Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> page = 2.0;
auto defaultResp = std::make_shared<GetHashTags_200_response>();
api->getHashTags(tenantId, page).then([defaultResp](pplx::task<std::shared_ptr<GetHashTags_200_response>> t) {
    try {
        auto resp = t.get();
        if(!resp) resp = defaultResp;
        std::cout << "getHashTags completed; response object " << (resp ? "present" : "absent") << std::endl;
    } catch(const std::exception& e) {
        std::cout << "getHashTags error: " << e.what() << std::endl;
    }
});

patchHashTag

Parametri

Name	Type	Required
tag	string	Yes
tenantId	string	No
updateHashTagBody	UpdateHashTagBody	No

Odgovor

Vraća: PatchHashTag_200_response

Primjer

patchHashTag Primjer

Copy

utility::string_t tag = U("release-1.0");
boost::optional<utility::string_t> tenantId = boost::optional<utility::string_t>(U("my-tenant-123"));
UpdateHashTagBody body;
boost::optional<UpdateHashTagBody> updateBody = boost::optional<UpdateHashTagBody>(body);
api->patchHashTag(tag, tenantId, updateBody)
.then([](pplx::task<std::shared_ptr<PatchHashTag_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            auto copied = std::make_shared<PatchHashTag_200_response>(*resp);
            std::cout << "PatchHashTag succeeded" << std::endl;
        } else {
            std::cout << "PatchHashTag returned no data" << std::endl;
        }
    } catch (const std::exception &e) {
        std::cerr << "PatchHashTag error: " << e.what() << std::endl;
    }
});

createModerator

Параметри

Назив	Тип	Обавезно	Опис
tenantId	string	Да
createModeratorBody	CreateModeratorBody	Да

Одговор

Враћа: CreateModerator_200_response

Пример

createModerator Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateModeratorBody createModeratorBody;
createModeratorBody.email = U("moderator@example.com");
createModeratorBody.displayName = U("Support Moderator");
createModeratorBody.roles = std::vector<utility::string_t>{ U("moderator"), U("support") };
createModeratorBody.notes = boost::optional<utility::string_t>(U("Temporary moderator for Q1"));
api->createModerator(tenantId, createModeratorBody)
.then([](pplx::task<std::shared_ptr<CreateModerator_200_response>> t)
{
    try
    {
        auto resp = t.get();
        auto respCopy = std::make_shared<CreateModerator_200_response>(*resp);
        (void)respCopy;
    }
    catch (const std::exception&)
    {
    }
});

deleteModerator

Параметри

Назив	Тип	Обавезно
tenantId	string	Да
id	string	Да
sendEmail	string	Не

Одговор

Враћа: FlagCommentPublic_200_response

Пример

deleteModerator Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t moderatorId = U("moderator-456");
boost::optional<utility::string_t> sendEmail = boost::optional<utility::string_t>(U("moderator@notifications.example.com"));
api->deleteModerator(tenantId, moderatorId, sendEmail)
    .then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
        try {
            auto resp = t.get();
            if (!resp) resp = std::make_shared<FlagCommentPublic_200_response>();
            return resp;
        } catch (const std::exception&) {
            return std::make_shared<FlagCommentPublic_200_response>();
        }
    });

getModerator

Параметри

Име	Тип	Обавезно	Опис
tenantId	string	Yes
id	string	Yes

Одговор

Враћа: GetModerator_200_response

Пример

getModerator Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t moderatorId = U("moderator-456");
boost::optional<utility::string_t> requestLocale = U("en-US");
auto fallbackModerator = std::make_shared<GetModerator_200_response>();
api->getModerator(tenantId, moderatorId)
    .then([fallbackModerator, requestLocale](std::shared_ptr<GetModerator_200_response> resp) -> pplx::task<std::shared_ptr<GetModerator_200_response>> {
        auto moderator = resp ? resp : fallbackModerator;
        if (requestLocale) { auto loc = *requestLocale; (void)loc; }
        return pplx::task_from_result(moderator);
    })
    .then([](std::shared_ptr<GetModerator_200_response> finalResp) -> void {
        (void)finalResp;
    });

getModerators

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Yes
skip	double	No

Odgovor

Vraća: GetModerators_200_response

Primjer

getModerators Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = boost::optional<double>(10);
auto task = api->getModerators(tenantId, skip)
    .then([](std::shared_ptr<GetModerators_200_response> resp) {
        if (!resp) {
            std::cout << "No moderators returned\n";
            return;
        }
        auto copy = std::make_shared<GetModerators_200_response>(*resp);
        std::cout << "Retrieved moderators\n";
    });
task.wait();

sendInvite

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
id	string	Da
fromName	string	Da

Odgovor

Vraća: FlagCommentPublic_200_response

Primjer

Primjer sendInvite

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("comment-456");
utility::string_t fromName = U("moderator@example.com");
boost::optional<utility::string_t> inviteNote = boost::optional<utility::string_t>(U("Please review this flagged comment"));
auto task = api->sendInvite(tenantId, id, fromName)
    .then([inviteNote](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) -> std::shared_ptr<FlagCommentPublic_200_response> {
        try {
            auto resp = t.get();
            auto wrapped = std::make_shared<FlagCommentPublic_200_response>(*resp);
            (void)inviteNote;
            return wrapped;
        } catch (...) {
            throw;
        }
    });

updateModerator

Параметри

Име	Тип	Обавезно
tenantId	string	Да
id	string	Да
updateModeratorBody	UpdateModeratorBody	Да

Одговор

Враћа: FlagCommentPublic_200_response

Пример

Пример за updateModerator

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t moderatorId = U("moderator-456");
auto bodyPtr = std::make_shared<UpdateModeratorBody>();
bodyPtr->email = utility::string_t(U("mod.jane@example.com"));
bodyPtr->displayName = boost::optional<utility::string_t>(utility::string_t(U("Jane Moderator")));
bodyPtr->enabled = boost::optional<bool>(true);
api->updateModerator(tenantId, moderatorId, *bodyPtr).then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            std::cout << "Moderator updated successfully" << std::endl;
        }
    } catch (const std::exception &e) {
        std::cerr << "Update failed: " << e.what() << std::endl;
    }
});

deleteNotificationCount

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: FlagCommentPublic_200_response

Primjer

deleteNotificationCount Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t notifId = U("notification-456");
boost::optional<utility::string_t> actingUser = boost::optional<utility::string_t>(U("moderator@example.com"));
api->deleteNotificationCount(tenantId, notifId)
.then([actingUser](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<FlagCommentPublic_200_response>();
        if (actingUser) std::cout << "Actor: " << actingUser->c_str() << "\n";
        std::cout << "Notification count cleared\n";
    } catch (const std::exception &e) {
        std::cout << "Failed: " << e.what() << "\n";
    }
});

getCachedNotificationCount

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: GetCachedNotificationCount_200_response

Primjer

getCachedNotificationCount Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user@example.com");
boost::optional<utility::string_t> opt_status = boost::optional<utility::string_t>(U("unread"));
api->getCachedNotificationCount(tenantId, userId)
    .then([=](pplx::task<std::shared_ptr<GetCachedNotificationCount_200_response>> t){
        try {
            std::shared_ptr<GetCachedNotificationCount_200_response> resp = t.get();
            if(!resp) return;
            auto copy = std::make_shared<GetCachedNotificationCount_200_response>(*resp);
        } catch(const std::exception &){
        }
    });

getNotificationCount

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
userId	string	Ne
urlId	string	Ne
fromCommentId	string	Ne
viewed	bool	Ne
type	string	Ne

Odgovor

Vraća: GetNotificationCount_200_response

Primjer

getNotificationCount Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> userId = U("user@example.com");
boost::optional<utility::string_t> urlId = U("https://www.example.com/article/456");
boost::optional<utility::string_t> fromCommentId = U("cmt-789");
boost::optional<bool> viewed = true;
boost::optional<utility::string_t> type = U("reply");
api->getNotificationCount(tenantId, userId, urlId, fromCommentId, viewed, type)
    .then([](pplx::task<std::shared_ptr<GetNotificationCount_200_response>> task){
        try {
            auto resp = task.get();
            auto result = resp ? resp : std::make_shared<GetNotificationCount_200_response>();
        } catch (const std::exception&) {
        }
    });

getNotifications

Параметри

Име	Тип	Обавезно
tenantId	string	Да
userId	string	Не
urlId	string	Не
fromCommentId	string	Не
viewed	bool	Не
type	string	Не
skip	double	Не

Одговор

Враћа: GetNotifications_200_response

Пример

getNotifications Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<utility::string_t> urlId = boost::optional<utility::string_t>(U("https://example.com/posts/42"));
boost::optional<utility::string_t> fromCommentId = boost::optional<utility::string_t>(U("cmt-98765"));
boost::optional<bool> viewed = boost::optional<bool>(true);
boost::optional<utility::string_t> type = boost::optional<utility::string_t>(U("reply"));
boost::optional<double> skip = boost::optional<double>(0.0);
api->getNotifications(tenantId, userId, urlId, fromCommentId, viewed, type, skip)
.then([](pplx::task<std::shared_ptr<GetNotifications_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto processed = std::make_shared<GetNotifications_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

updateNotification

Parametri

Ime	Tip	Obavezno
tenantId	string	Da
id	string	Da
updateNotificationBody	UpdateNotificationBody	Da
userId	string	Ne

Odgovor

Vraća: FlagCommentPublic_200_response

Primjer

Primjer updateNotification

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t notificationId = U("notif-456");
UpdateNotificationBody updateNotificationBody;
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("moderator@example.com"));
api->updateNotification(tenantId, notificationId, updateNotificationBody, userId)
.then([=](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            auto respCopy = std::make_shared<FlagCommentPublic_200_response>(*resp);
            std::cout << "Notification updated successfully\n";
        } else {
            std::cout << "No response received\n";
        }
    } catch (const std::exception &e) {
        std::cerr << "Update failed: " << e.what() << "\n";
    }
});

addPage

Параметри

Name	Type	Required	Description
tenantId	string	Да
createAPIPageData	CreateAPIPageData	Да

Одговор

Враћа: AddPageAPIResponse

Пример

addPage Пример

Copy

auto pageData = std::make_shared<CreateAPIPageData>();
pageData->url = utility::string_t(U("https://example.com/articles/2025-modern-cpp"));
pageData->title = utility::string_t(U("Modern C++ Patterns"));
pageData->description = boost::optional<utility::string_t>(utility::string_t(U("Practical patterns for modern C++ development")));
pageData->authorEmail = boost::optional<utility::string_t>(utility::string_t(U("dev@company.com")));
pageData->published = boost::optional<bool>(true);
api->addPage(utility::string_t(U("my-tenant-123")), *pageData)
.then([](pplx::task<std::shared_ptr<AddPageAPIResponse>> t){
    try {
        auto resp = t.get();
        return resp;
    } catch (...) {
        throw;
    }
});

deletePage

Параметри

Назив	Тип	Обавезно	Опис
tenantId	string	Да
id	string	Да

Одговор

Враћа: DeletePageAPIResponse

Примјер

deletePage Примјер

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t pageId = U("page-456");
boost::optional<utility::string_t> correlationId = boost::optional<utility::string_t>(U("corr-20251122"));
auto task = api->deletePage(tenantId, pageId)
    .then([correlationId](pplx::task<std::shared_ptr<DeletePageAPIResponse>> prev) -> std::shared_ptr<DeletePageAPIResponse> {
        try {
            auto resp = prev.get();
            if (resp) return resp;
            return std::make_shared<DeletePageAPIResponse>();
        } catch (const std::exception&) {
            return std::make_shared<DeletePageAPIResponse>();
        }
    });

getPageByURLId

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
urlId	string	Da

Odgovor

Vraća: GetPageByURLIdAPIResponse

Primjer

getPageByURLId Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("home-page-789");
boost::optional<utility::string_t> locale = boost::optional<utility::string_t>(U("en-US"));
api->getPageByURLId(tenantId, urlId).then([=](pplx::task<std::shared_ptr<GetPageByURLIdAPIResponse>> task){
    try {
        auto resp = task.get();
        auto result = resp ? resp : std::make_shared<GetPageByURLIdAPIResponse>();
        (void)result;
    } catch (const std::exception &ex) {
        auto err = std::make_shared<GetPageByURLIdAPIResponse>();
        (void)err;
    }
});

getPages

Параметри

Име	Тип	Обавезно	Опис
tenantId	string	Да

Одговор

Враћа: GetPagesAPIResponse

Пример

getPages Пример

Copy

int main()
{
    utility::string_t tenantId = U("my-tenant-123");
    boost::optional<utility::string_t> statusFilter = U("published");
    boost::optional<int> pageNumber = 1;
    auto placeholder = std::make_shared<GetPagesAPIResponse>();
    api->getPages(tenantId)
       .then([placeholder](std::shared_ptr<GetPagesAPIResponse> resp) {
           if (resp) {
               *placeholder = *resp;
               auto refs = resp.use_count();
               (void)refs;
           }
       })
       .wait();
    return 0;
}

patchPage

Параметри

Назив	Тип	Обавезно
tenantId	string	Да
id	string	Да
updateAPIPageData	UpdateAPIPageData	Да

Одговор

Враћа: PatchPageAPIResponse

Пример

patchPage Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t pageId = U("page-9876");
auto updatePtr = std::make_shared<UpdateAPIPageData>();
updatePtr->title = utility::string_t(U("About Our Team"));
updatePtr->slug = utility::string_t(U("about-our-team"));
updatePtr->enabled = boost::optional<bool>(true);
updatePtr->description = boost::optional<utility::string_t>(U("Updated team overview and contact information"));
api->patchPage(tenantId, pageId, *updatePtr)
.then([](pplx::task<std::shared_ptr<PatchPageAPIResponse>> t){
    try {
        auto resp = t.get();
        if (resp) {
            std::cout << "Patch successful, page id: " << resp->id << std::endl;
        }
    } catch (const std::exception &e) {
        std::cerr << "Patch failed: " << e.what() << std::endl;
    }
});

deletePendingWebhookEvent

Параметри

Назив	Тип	Обавезно	Опис
tenantId	string	Да
id	string	Да

Одговор

Враћа: FlagCommentPublic_200_response

Пример

deletePendingWebhookEvent Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t eventId = U("wh_evt_456");
boost::optional<utility::string_t> requestId = boost::optional<utility::string_t>(U("req-789"));
api->deletePendingWebhookEvent(tenantId, eventId)
    .then([requestId](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
        try {
            auto resp = t.get();
            if (resp) {
                auto resultCopy = std::make_shared<FlagCommentPublic_200_response>(*resp);
                if (requestId) {
                    (void)requestId.get();
                }
                (void)resultCopy;
            } else {
                auto fallback = std::make_shared<FlagCommentPublic_200_response>();
                (void)fallback;
            }
        } catch (const std::exception&) {
            auto errorObj = std::make_shared<FlagCommentPublic_200_response>();
            (void)errorObj;
        }
    }).wait();

getPendingWebhookEventCount

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
commentId	string	Ne
externalId	string	Ne
eventType	string	Ne
type	string	Ne
domain	string	Ne
attemptCountGT	double	Ne

Odgovor

Vraća: GetPendingWebhookEventCount_200_response

Primjer

getPendingWebhookEventCount Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> commentId = boost::optional<utility::string_t>(U("cmt-789"));
boost::optional<utility::string_t> externalId = boost::optional<utility::string_t>(U("ext-456"));
boost::optional<utility::string_t> eventType = boost::optional<utility::string_t>(U("comment_created"));
boost::optional<utility::string_t> type = boost::optional<utility::string_t>(U("webhook"));
boost::optional<utility::string_t> domain = boost::optional<utility::string_t>(U("example.com"));
boost::optional<double> attemptCountGT = boost::optional<double>(1.0);
api->getPendingWebhookEventCount(tenantId, commentId, externalId, eventType, type, domain, attemptCountGT)
.then([](pplx::task<std::shared_ptr<GetPendingWebhookEventCount_200_response>> t){
    try {
        auto resp = t.get();
        auto respCopy = std::make_shared<GetPendingWebhookEventCount_200_response>(*resp);
        std::cout << "Pending webhook event count retrieved\n";
    } catch (const std::exception &e) {
        std::cerr << "Failed to get pending count: " << e.what() << '\n';
    }
}).wait();

getPendingWebhookEvents

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
commentId	string	Ne
externalId	string	Ne
eventType	string	Ne
type	string	Ne
domain	string	Ne
attemptCountGT	double	Ne
skip	double	Ne

Odgovor

Vraća: GetPendingWebhookEvents_200_response

Primjer

Primjer getPendingWebhookEvents

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> commentId = boost::optional<utility::string_t>(U("cmt-98765"));
boost::optional<utility::string_t> externalId = boost::optional<utility::string_t>(U("ext-abc-01"));
boost::optional<utility::string_t> eventType = boost::optional<utility::string_t>(U("comment_created"));
boost::optional<utility::string_t> type = boost::optional<utility::string_t>(U("webhook"));
boost::optional<utility::string_t> domain = boost::optional<utility::string_t>(U("example.com"));
boost::optional<double> attemptCountGT = boost::optional<double>(2.0);
boost::optional<double> skip = boost::optional<double>(0.0);
api->getPendingWebhookEvents(tenantId, commentId, externalId, eventType, type, domain, attemptCountGT, skip)
.then([](pplx::task<std::shared_ptr<GetPendingWebhookEvents_200_response>> t) {
    try {
        auto resp = t.get();
        auto copy = std::make_shared<GetPendingWebhookEvents_200_response>(*resp);
        (void)copy;
    } catch (const std::exception& e) {
        (void)e;
        auto empty = std::make_shared<GetPendingWebhookEvents_200_response>();
        (void)empty;
    }
});

createQuestionConfig

Parametri

Name	Tip	Obavezno	Opis
tenantId	string	Da
createQuestionConfigBody	CreateQuestionConfigBody	Da

Odgovor

Vraća: CreateQuestionConfig_200_response

Primjer

Primjer createQuestionConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateQuestionConfigBody body;
body.name = utility::string_t(U("Feature X Feedback"));
body.description = boost::optional<utility::string_t>(utility::string_t(U("Ask users if Feature X met their needs")));
body.createdBy = utility::string_t(U("admin@mycompany.com"));
body.enabled = boost::optional<bool>(true);
api->createQuestionConfig(tenantId, body).then([](std::shared_ptr<CreateQuestionConfig_200_response> resp){
    if(resp){
        auto result = std::make_shared<CreateQuestionConfig_200_response>(*resp);
        std::wcout << U("Question config created successfully") << std::endl;
    } else {
        std::wcout << U("Failed to create question config") << std::endl;
    }
});

deleteQuestionConfig

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: FlagCommentPublic_200_response

Primjer

deleteQuestionConfig Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("qcfg-98765");
boost::optional<utility::string_t> tenantOpt = tenantId;
auto t = api->deleteQuestionConfig(tenantOpt.value_or(utility::string_t()), id)
.then([](std::shared_ptr<FlagCommentPublic_200_response> resp) -> std::shared_ptr<FlagCommentPublic_200_response> {
    auto out = std::make_shared<FlagCommentPublic_200_response>();
    if (resp) *out = *resp;
    return out;
});
t.wait();

getQuestionConfig

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: GetQuestionConfig_200_response

Primer

getQuestionConfig Primer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("question-456");
boost::optional<utility::string_t> locale = U("en-US");
auto defaultResp = std::make_shared<GetQuestionConfig_200_response>();
api->getQuestionConfig(tenantId, id).then([defaultResp](pplx::task<std::shared_ptr<GetQuestionConfig_200_response>> t) {
    try {
        auto resp = t.get();
        if(!resp) resp = defaultResp;
        std::cout << "Question config retrieved" << std::endl;
    } catch(const std::exception &e) {
        std::cerr << "Failed to get question config: " << e.what() << std::endl;
    }
});

getQuestionConfigs

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
skip	double	Ne

Odgovor

Vraća: GetQuestionConfigs_200_response

Primjer

getQuestionConfigs Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = 10;
api->getQuestionConfigs(tenantId, skip).then([](pplx::task<std::shared_ptr<GetQuestionConfigs_200_response>> task) {
    try {
        auto resp = task.get();
        if (resp) {
            auto localCopy = std::make_shared<GetQuestionConfigs_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

updateQuestionConfig

Параметри

Назив	Тип	Обавезно
tenantId	string	Да
id	string	Да
updateQuestionConfigBody	UpdateQuestionConfigBody	Да

Одговор

Враћа: FlagCommentPublic_200_response

Пример

updateQuestionConfig Пример

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto configId = utility::string_t(U("question-config-456"));
auto body = std::make_shared<UpdateQuestionConfigBody>();
body->enabled = true;
body->threshold = 5;
body->moderatorEmail = utility::string_t(U("moderator@example.com"));
body->notifyUsers = boost::optional<bool>(true);
body->description = boost::optional<utility::string_t>(utility::string_t(U("Tighten question moderation for new users")));
api->updateQuestionConfig(tenantId, configId, *body)
    .then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
        try {
            auto resp = t.get();
            std::cout << (resp ? "updateQuestionConfig succeeded\n" : "updateQuestionConfig returned null\n");
        } catch (const std::exception& e) {
            std::cerr << "updateQuestionConfig failed: " << e.what() << '\n';
        }
    });

createQuestionResult

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
createQuestionResultBody	CreateQuestionResultBody	Da

Odgovor

Vraća: CreateQuestionResult_200_response

Primjer

Primjer createQuestionResult

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateQuestionResultBody createQuestionResultBody;
createQuestionResultBody.questionId = U("question-789");
createQuestionResultBody.userEmail = U("student@example.com");
createQuestionResultBody.selectedOption = U("B");
createQuestionResultBody.isCorrect = true;
createQuestionResultBody.score = 9.5;
createQuestionResultBody.metadata = boost::optional<utility::string_t>(U("{\"session\":\"quiz-2026-01\"}"));
auto task = api->createQuestionResult(tenantId, createQuestionResultBody)
.then([](pplx::task<std::shared_ptr<CreateQuestionResult_200_response>> t){
    try {
        auto result = t.get();
        auto copy = std::make_shared<CreateQuestionResult_200_response>(*result);
        (void)copy;
    } catch (...) {}
});
task.wait();

deleteQuestionResult

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: FlagCommentPublic_200_response

Primjer

deleteQuestionResult Primjer

Copy

boost::optional<utility::string_t> maybeTenant = boost::none;
utility::string_t defaultTenant = U("my-tenant-123");
utility::string_t questionId = U("question-456");
utility::string_t tenant = maybeTenant ? *maybeTenant : defaultTenant;
api->deleteQuestionResult(tenant, questionId)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> task){
    try {
        auto resp = task.get();
        auto processed = std::make_shared<FlagCommentPublic_200_response>(*resp);
    } catch (const std::exception&) {
    }
});

getQuestionResult

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: GetQuestionResult_200_response

Primjer

getQuestionResult Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t questionId = U("question-456");
boost::optional<utility::string_t> requestor = U("user@example.com");
auto task = api->getQuestionResult(tenantId, questionId)
    .then([requestor](pplx::task<std::shared_ptr<GetQuestionResult_200_response>> prev) -> std::shared_ptr<GetQuestionResult_200_response> {
        try {
            auto resp = prev.get();
            if (!resp) return std::make_shared<GetQuestionResult_200_response>();
            (void)requestor;
            return resp;
        } catch (const std::exception &) {
            return std::make_shared<GetQuestionResult_200_response>();
        }
    });

getQuestionResults

Parametri

Name	Type	Required
tenantId	string	Da
urlId	string	Ne
userId	string	Ne
startDate	string	Ne
questionId	string	Ne
questionIds	string	Ne
skip	double	Ne

Odgovor

Vraća: GetQuestionResults_200_response

Primjer

getQuestionResults Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> urlId = boost::optional<utility::string_t>(U("/articles/2025/new-feature"));
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("alice@example.com"));
boost::optional<utility::string_t> startDate = boost::optional<utility::string_t>(U("2025-01-01T00:00:00Z"));
boost::optional<utility::string_t> questionId = boost::optional<utility::string_t>(U("q-789"));
boost::optional<utility::string_t> questionIds = boost::optional<utility::string_t>(U("q-789,q-790"));
boost::optional<double> skip = boost::optional<double>(10.0);
api->getQuestionResults(tenantId, urlId, userId, startDate, questionId, questionIds, skip)
.then([](pplx::task<std::shared_ptr<GetQuestionResults_200_response>> t){
    try {
        std::shared_ptr<GetQuestionResults_200_response> resp = t.get();
        if (resp) {
            auto copy = std::make_shared<GetQuestionResults_200_response>(*resp);
        }
    } catch (const std::exception&) {}
});

updateQuestionResult

Parametri

Name	Type	Required
tenantId	string	Da
id	string	Da
updateQuestionResultBody	UpdateQuestionResultBody	Da

Odgovor

Vraća: FlagCommentPublic_200_response

Primjer

Primjer updateQuestionResult

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("question-456");
UpdateQuestionResultBody updateQuestionResultBody;
auto moderatorEmail = std::make_shared<utility::string_t>(U("moderator@example.com"));
boost::optional<utility::string_t> resolutionNote = boost::optional<utility::string_t>(U("Marked duplicate of q-123"));
api->updateQuestionResult(tenantId, id, updateQuestionResultBody)
    .then([moderatorEmail, resolutionNote](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t)
    {
        try {
            auto resp = t.get();
            if (resp) {
                auto resultPtr = resp;
            }
        } catch (...) {}
    });

aggregateQuestionResults

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
questionId	string	Ne
questionIds	vector<string	Ne
urlId	string	Ne
timeBucket	AggregateTimeBucket	Ne
startDate	datetime	Ne
forceRecalculate	bool	Ne

Odgovor

Vraća: AggregateQuestionResults_200_response

Primjer

aggregateQuestionResults Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> questionId(U("q-42"));
boost::optional<std::vector<utility::string_t>> questionIds(std::vector<utility::string_t>{U("q-42"), U("q-43")});
boost::optional<utility::string_t> urlId(U("page-789"));
boost::optional<AggregateTimeBucket> timeBucket;
boost::optional<utility::datetime> startDate(utility::datetime::from_string(U("2025-01-01T00:00:00Z")));
boost::optional<bool> forceRecalculate(true);
api->aggregateQuestionResults(tenantId, questionId, questionIds, urlId, timeBucket, startDate, forceRecalculate)
.then([](std::shared_ptr<AggregateQuestionResults_200_response> resp){
    if (resp) {
        auto resultCopy = std::make_shared<AggregateQuestionResults_200_response>(*resp);
    }
});

bulkAggregateQuestionResults

Parametri

Name	Type	Required
tenantId	string	Da
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Da
forceRecalculate	bool	Ne

Odgovor

Vraća: BulkAggregateQuestionResults_200_response

Primjer

bulkAggregateQuestionResults Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
BulkAggregateQuestionResultsRequest request;
boost::optional<bool> forceRecalculate(true);
api->bulkAggregateQuestionResults(tenantId, request, forceRecalculate)
.then([](pplx::task<std::shared_ptr<BulkAggregateQuestionResults_200_response>> t){
    try {
        auto resp = t.get();
        if (!resp) {
            auto empty = std::make_shared<BulkAggregateQuestionResults_200_response>();
            std::cout << "No aggregated results returned\n";
        } else {
            std::cout << "Aggregated results received\n";
        }
    } catch (const std::exception& ex) {
        std::cerr << "Error fetching aggregated results: " << ex.what() << '\n';
    }
});

combineCommentsWithQuestionResults

Параметри

Name	Type	Required
tenantId	string	Да
questionId	string	Не
questionIds	vector<string	Не
urlId	string	Не
startDate	datetime	Не
forceRecalculate	bool	Не
minValue	double	Не
maxValue	double	Не
limit	double	Не

Одговор

Враћа: CombineCommentsWithQuestionResults_200_response

Пример

Пример combineCommentsWithQuestionResults

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> questionId = boost::optional<utility::string_t>(U("q-98765"));
boost::optional<std::vector<utility::string_t>> questionIds = boost::optional<std::vector<utility::string_t>>(std::vector<utility::string_t>{U("q-98765"), U("q-12345")});
boost::optional<utility::string_t> urlId = boost::optional<utility::string_t>(U("/posts/2024/interesting-article"));
boost::optional<utility::datetime> startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2024-01-01T00:00:00Z")));
boost::optional<bool> forceRecalculate = boost::optional<bool>(true);
boost::optional<double> minValue = boost::optional<double>(0.0);
boost::optional<double> maxValue = boost::optional<double>(1.0);
boost::optional<double> limit = boost::optional<double>(100.0);
api->combineCommentsWithQuestionResults(tenantId, questionId, questionIds, urlId, startDate, forceRecalculate, minValue, maxValue, limit)
.then([](pplx::task<std::shared_ptr<CombineCommentsWithQuestionResults_200_response>> task){
    try {
        auto response = task.get();
        auto output = response ? response : std::make_shared<CombineCommentsWithQuestionResults_200_response>();
    } catch (const std::exception&) {
    }
});

addSSOUser

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
createAPISSOUserData	CreateAPISSOUserData	Da

Odgovor

Vraća: AddSSOUserAPIResponse

Primjer

Primjer addSSOUser

Copy

utility::string_t tenantId = U("my-tenant-123");
auto createData = std::make_shared<CreateAPISSOUserData>();
createData->email = utility::string_t(U("alice@example.com"));
createData->externalUserId = utility::string_t(U("okta|987654321"));
createData->displayName = boost::optional<utility::string_t>(U("Alice Johnson"));
createData->roles = std::vector<utility::string_t>{ U("moderator"), U("editor") };
api->addSSOUser(tenantId, createData)
.then([](pplx::task<std::shared_ptr<AddSSOUserAPIResponse>> task){
    try {
        auto resp = task.get();
        if (resp) {
            (void)resp;
        }
    } catch (...) {
    }
});

deleteSSOUser

Параметри

Назив	Тип	Обавезно
tenantId	string	Да
id	string	Да
deleteComments	bool	Не
commentDeleteMode	string	Не

Одговор

Враћа: DeleteSSOUserAPIResponse

Примјер

deleteSSOUser Примјер

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t ssoId = U("user@example.com");
boost::optional<bool> deleteComments = true;
boost::optional<utility::string_t> commentDeleteMode = U("anonymize");
api->deleteSSOUser(tenantId, ssoId, deleteComments, commentDeleteMode)
.then([](pplx::task<std::shared_ptr<DeleteSSOUserAPIResponse>> t){
    try {
        auto resp = t.get();
        auto respCopy = std::make_shared<DeleteSSOUserAPIResponse>(*resp);
        (void)respCopy;
    } catch (const std::exception&) {
    }
});

getSSOUserByEmail

Параметри

Име	Тип	Обавезно	Опис
tenantId	string	Да
email	string	Да

Одговор

Враћа: GetSSOUserByEmailAPIResponse

Пример

getSSOUserByEmail Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t email = U("user@example.com");
boost::optional<utility::string_t> includeInactive = boost::optional<utility::string_t>(U("false"));
api->getSSOUserByEmail(tenantId, email).then([includeInactive](pplx::task<std::shared_ptr<GetSSOUserByEmailAPIResponse>> t) {
    try {
        auto resp = t.get();
        return resp ? resp : std::make_shared<GetSSOUserByEmailAPIResponse>();
    } catch (...) {
        return std::make_shared<GetSSOUserByEmailAPIResponse>();
    }
}).then([](std::shared_ptr<GetSSOUserByEmailAPIResponse> finalResp) {
    (void)finalResp;
});

getSSOUserById

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: GetSSOUserByIdAPIResponse

Primjer

Primjer getSSOUserById

Copy

boost::optional<utility::string_t> optId = U("user-42@example.com");
utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = optId.value_or(U("user-42@example.com"));
api->getSSOUserById(tenantId, id).then([](pplx::task<std::shared_ptr<GetSSOUserByIdAPIResponse>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto out = resp;
            (void)out;
        } else {
            auto fallback = std::make_shared<GetSSOUserByIdAPIResponse>();
            (void)fallback;
        }
    } catch (const std::exception& ex) {
        auto fallback = std::make_shared<GetSSOUserByIdAPIResponse>();
        (void)ex;
        (void)fallback;
    }
});

getSSOUsers

Параметри

Име	Тип	Обавезно	Опис
tenantId	string	Да
skip	int32_t	Не

Одговор

Враћа: GetSSOUsers_200_response

Пример

Пример getSSOUsers

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<int32_t> skip = 10;
api->getSSOUsers(tenantId, skip).then([](pplx::task<std::shared_ptr<GetSSOUsers_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<GetSSOUsers_200_response>(*resp);
        }
    } catch(...) {}
});

patchSSOUser

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
id	string	Da
updateAPISSOUserData	UpdateAPISSOUserData	Da
updateComments	bool	Ne

Odgovor

Vraća: PatchSSOUserAPIResponse

Primjer

patchSSOUser Primjer

Copy

UpdateAPISSOUserData updateData;
updateData.email = utility::string_t(U"user@example.com");
updateData.displayName = utility::string_t(U"Jane Doe");
boost::optional<bool> updateComments = true;
auto responseHolder = std::make_shared<PatchSSOUserAPIResponse>();
api->patchSSOUser(utility::string_t(U"my-tenant-123"), utility::string_t(U"user@example.com"), updateData, updateComments)
.then([responseHolder](std::shared_ptr<PatchSSOUserAPIResponse> resp){
    if (resp) *responseHolder = *resp;
    return responseHolder;
});

putSSOUser

Параметри

Назив	Тип	Обавезно
tenantId	string	Да
id	string	Да
updateAPISSOUserData	UpdateAPISSOUserData	Да
updateComments	bool	Не

Одговор

Враћа: PutSSOUserAPIResponse

Пример

putSSOUser Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("user@example.com");
UpdateAPISSOUserData updateData;
updateData.displayName = U("Jane Doe");
updateData.email = U("user@example.com");
boost::optional<bool> updateComments = true;
api->putSSOUser(tenantId, id, updateData, updateComments)
.then([](std::shared_ptr<PutSSOUserAPIResponse> resp){
    if(!resp){ std::cout << "putSSOUser returned null\n"; return; }
    auto copy = std::make_shared<PutSSOUserAPIResponse>(*resp);
    std::cout << "SSO user updated successfully\n";
});

createSubscription

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Da

Odgovor

Vraća: CreateSubscriptionAPIResponse

Primjer

createSubscription Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
auto payload = std::make_shared<CreateAPIUserSubscriptionData>();
payload->userEmail = U("user@example.com");
payload->planId = U("pro-monthly");
payload->couponCode = boost::optional<utility::string_t>(U("WELCOME10"));
payload->trialDays = boost::optional<int>(14);
payload->autoRenew = boost::optional<bool>(true);
api->createSubscription(tenantId, *payload).then([](std::shared_ptr<CreateSubscriptionAPIResponse> resp) {
    if (resp) std::cout << "Subscription created successfully" << std::endl;
    else std::cout << "Failed to create subscription" << std::endl;
});

deleteSubscription

Параметри

Име	Тип	Обавезно
tenantId	string	Да
id	string	Да
userId	string	Не

Одговор

Враћа: DeleteSubscriptionAPIResponse

Пример

Пример deleteSubscription

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("subscription-987");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
auto defaultResp = std::make_shared<DeleteSubscriptionAPIResponse>();
api->deleteSubscription(tenantId, id, userId)
.then([defaultResp](pplx::task<std::shared_ptr<DeleteSubscriptionAPIResponse>> t){
    try {
        auto resp = t.get();
        if (!resp) resp = defaultResp;
        std::cout << "Delete completed\n";
    } catch (const std::exception &e) {
        std::cerr << "Delete failed: " << e.what() << '\n';
    }
});

getSubscriptions

Параметри

Name	Type	Required	Description
tenantId	string	Да
userId	string	Не

Одговор

Враћа: GetSubscriptionsAPIResponse

Пример

getSubscriptions Пример

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> userId = utility::conversions::to_string_t("user@example.com");
api->getSubscriptions(tenantId, userId)
.then([](std::shared_ptr<GetSubscriptionsAPIResponse> resp){
    if(!resp) return;
    auto copy = std::make_shared<GetSubscriptionsAPIResponse>(*resp);
})
.wait();

updateSubscription

Parametri

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

Odgovor

Vraća: UpdateSubscriptionAPIResponse

Primjer

Primjer updateSubscription

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t subscriptionId = U("sub-456");
UpdateAPIUserSubscriptionData updateData{};
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user-789"));
api->updateSubscription(tenantId, subscriptionId, updateData, userId)
.then([](pplx::task<std::shared_ptr<UpdateSubscriptionAPIResponse>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<UpdateSubscriptionAPIResponse>(*resp);
        }
    } catch (const std::exception&) {}
}).wait();

getTenantDailyUsages

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
yearNumber	double	Ne
monthNumber	double	Ne
dayNumber	double	Ne
skip	double	Ne

Odgovor

Vraća: GetTenantDailyUsages_200_response

Primjer

Primjer getTenantDailyUsages

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> year = 2025;
boost::optional<double> month = 1;
auto placeholder = std::make_shared<GetTenantDailyUsages_200_response>();
api->getTenantDailyUsages(tenantId, year, month, boost::optional<double>(), boost::optional<double>())
.then([](pplx::task<std::shared_ptr<GetTenantDailyUsages_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) std::cout << "Received tenant daily usages\n";
        else std::cout << "No usage data\n";
    } catch (const std::exception &e) {
        std::cout << "Request error: " << e.what() << '\n';
    }
});

createTenantPackage

Параметри

Име	Тип	Обавезно	Опис
tenantId	string	Да
createTenantPackageBody	CreateTenantPackageBody	Да

Одговор

Враћа: CreateTenantPackage_200_response

Пример

createTenantPackage Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
auto body = std::make_shared<CreateTenantPackageBody>();
body->name = U("Standard Package - 1k comments");
body->createdByEmail = U("admin@mycompany.com");
body->monthlyLimit = boost::optional<int>(1000);
body->notes = boost::optional<utility::string_t>(U("Onboarding promo"));
api->createTenantPackage(tenantId, *body)
.then([](pplx::task<std::shared_ptr<CreateTenantPackage_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) {
            std::cout << "Package created: " << utility::conversions::to_utf8string(resp->packageId) << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << "Create failed: " << e.what() << std::endl;
    }
});

deleteTenantPackage

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: FlagCommentPublic_200_response

Primjer

deleteTenantPackage Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t pkgId = U("package-456");
boost::optional<utility::string_t> ifMatch = boost::optional<utility::string_t>(U("\"etag-789\""));
auto fallback = std::make_shared<FlagCommentPublic_200_response>();
auto task = api->deleteTenantPackage(tenantId, pkgId).then([fallback](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
    try {
        auto resp = t.get();
        if (resp) return resp;
        return fallback;
    } catch (const std::exception&) {
        return fallback;
    }
});
task.wait();

getTenantPackage

Parametri

Naziv	Type	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: GetTenantPackage_200_response

Primjer

getTenantPackage Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t packageId = U("pkg-456");
boost::optional<utility::string_t> requestTrace = U("trace-20260112-01");
api->getTenantPackage(tenantId, packageId)
.then([requestTrace](std::shared_ptr<GetTenantPackage_200_response> resp){
    auto result = resp ? resp : std::make_shared<GetTenantPackage_200_response>();
    if (requestTrace) { auto trace = *requestTrace; (void)trace; }
    return result;
})
.then([](std::shared_ptr<GetTenantPackage_200_response> finalResp){
    (void)finalResp;
});

getTenantPackages

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
skip	double	Ne

Odgovor

Vraća: GetTenantPackages_200_response

Primjer

Primjer getTenantPackages

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = 10.0;
auto task = api->getTenantPackages(tenantId, skip).then([](pplx::task<std::shared_ptr<GetTenantPackages_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            (void)resp;
        }
    } catch (const std::exception&) {
        auto fallback = std::make_shared<GetTenantPackages_200_response>();
        (void)fallback;
    }
});

replaceTenantPackage

Parametri

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

Odgovor

Vraća: FlagCommentPublic_200_response

Primjer

Primjer replaceTenantPackage

Copy

utility::string_t tenantId = utility::string_t("my-tenant-123");
utility::string_t packageId = utility::string_t("pkg-456");
ReplaceTenantPackageBody body;
body.name = utility::string_t("Premium Plan");
body.planId = utility::string_t("premium_monthly");
body.seats = 25;
body.billingEmail = utility::string_t("billing@acme.com");
boost::optional<utility::string_t> notes = boost::optional<utility::string_t>(utility::string_t("Migrated subscription"));
body.notes = notes;
api->replaceTenantPackage(tenantId, packageId, body).then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> task){
    try{
        auto resp = task.get();
        if(resp){
            auto resultCopy = std::make_shared<FlagCommentPublic_200_response>(*resp);
        }
    } catch(const std::exception&){
    }
});

updateTenantPackage

Parametri

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

Odgovor

Vraća: FlagCommentPublic_200_response

Primjer

Primjer updateTenantPackage

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t packageId = U("pkg-456");
auto bodyPtr = std::make_shared<UpdateTenantPackageBody>();
bodyPtr->name = utility::string_t(U("Pro Monthly"));
bodyPtr->description = boost::optional<utility::string_t>(U("Monthly subscription for pro users"));
bodyPtr->enabled = boost::optional<bool>(true);
api->updateTenantPackage(tenantId, packageId, *bodyPtr)
.then([](std::shared_ptr<FlagCommentPublic_200_response> resp){
    std::cout << (resp ? "updateTenantPackage succeeded\n" : "updateTenantPackage returned null\n");
});

createTenantUser

Параметри

Име	Тип	Обавезно	Опис
tenantId	string	Да
createTenantUserBody	CreateTenantUserBody	Да

Одговор

Враћа: CreateTenantUser_200_response

Пример

createTenantUser Пример

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
CreateTenantUserBody createTenantUserBody;
createTenantUserBody.email = utility::conversions::to_string_t("new.user@company.com");
createTenantUserBody.displayName = boost::optional<utility::string_t>(utility::conversions::to_string_t("New User"));
api->createTenantUser(tenantId, createTenantUserBody)
    .then([](pplx::task<std::shared_ptr<CreateTenantUser_200_response>> task){
        try {
            auto resp = task.get();
            auto created = std::make_shared<CreateTenantUser_200_response>(*resp);
        } catch (const std::exception&) {
        }
    });

deleteTenantUser

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
id	string	Da
deleteComments	string	Ne
commentDeleteMode	string	Ne

Odgovor

Vraća: FlagCommentPublic_200_response

Primjer

Primjer deleteTenantUser

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user@example.com");
boost::optional<utility::string_t> deleteComments = boost::optional<utility::string_t>(U("true"));
boost::optional<utility::string_t> commentDeleteMode = boost::optional<utility::string_t>(U("soft"));
auto fallback = std::make_shared<FlagCommentPublic_200_response>();
api->deleteTenantUser(tenantId, userId, deleteComments, commentDeleteMode)
.then([fallback](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
    try {
        auto resp = t.get();
        if (!resp) resp = fallback;
        std::cout << "deleteTenantUser completed\n";
    } catch (const std::exception &e) {
        std::cout << "deleteTenantUser failed: " << e.what() << "\n";
    }
}).wait();

getTenantUser

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: GetTenantUser_200_response

Primjer

getTenantUser Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("alice@example.com");
boost::optional<utility::string_t> includeMetadata = boost::optional<utility::string_t>(U("true"));
api->getTenantUser(tenantId, userId).then([includeMetadata](pplx::task<std::shared_ptr<GetTenantUser_200_response>> t)
{
    try {
        auto resp = t.get();
        auto result = resp ? resp : std::make_shared<GetTenantUser_200_response>();
        if (includeMetadata && result) { (void)includeMetadata; }
        (void)result;
    } catch (const std::exception& e) {
        auto fallback = std::make_shared<GetTenantUser_200_response>();
        (void)fallback;
    }
});

getTenantUsers

Параметри

Назив	Тип	Обавезно	Опис
tenantId	string	Да
skip	double	Не

Одговор

Враћа: GetTenantUsers_200_response

Пример

getTenantUsers Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = boost::optional<double>(20);
api->getTenantUsers(tenantId, skip)
    .then([=](pplx::task<std::shared_ptr<GetTenantUsers_200_response>> t) {
        try {
            std::shared_ptr<GetTenantUsers_200_response> resp = t.get();
            if (!resp) resp = std::make_shared<GetTenantUsers_200_response>();
            (void)resp;
        } catch (const std::exception& ex) {
            (void)ex;
            std::shared_ptr<GetTenantUsers_200_response> err = std::make_shared<GetTenantUsers_200_response>();
        }
    });

replaceTenantUser

Parametri

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

Odgovor

Vraća: FlagCommentPublic_200_response

Primjer

Primjer replaceTenantUser

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("user@example.com");
ReplaceTenantUserBody replaceBody;
boost::optional<utility::string_t> updateComments = boost::optional<utility::string_t>(U("true"));
api->replaceTenantUser(tenantId, id, replaceBody, updateComments)
.then([](std::shared_ptr<FlagCommentPublic_200_response> resp){
    if (resp) {
        auto copy = std::make_shared<FlagCommentPublic_200_response>(*resp);
    }
});

sendLoginLink

Параметри

Име	Тип	Обавезно
tenantId	string	Да
id	string	Да
redirectURL	string	Не

Одговор

Враћа: FlagCommentPublic_200_response

Примјер

Примјер за sendLoginLink

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user@example.com");
boost::optional<utility::string_t> redirectURL = utility::string_t(U("https://app.example.com/welcome"));
api->sendLoginLink(tenantId, userId, redirectURL)
    .then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t)
    {
        try
        {
            auto resp = t.get();
            if (resp) return resp;
            return std::make_shared<FlagCommentPublic_200_response>();
        }
        catch (...)
        {
            return std::make_shared<FlagCommentPublic_200_response>();
        }
    });

updateTenantUser

Параметри

Назив	Тип	Обавезно
tenantId	string	Да
id	string	Да
updateTenantUserBody	UpdateTenantUserBody	Да
updateComments	string	Не

Одговор

Враћа: FlagCommentPublic_200_response

Пример

Пример за updateTenantUser

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("jane.doe@example.com");
auto bodyPtr = std::make_shared<UpdateTenantUserBody>();
bodyPtr->setEmail(U("jane.doe@example.com"));
bodyPtr->setDisplayName(U("Jane Doe"));
boost::optional<utility::string_t> updateComments = U("Normalized display name");
api->updateTenantUser(tenantId, userId, *bodyPtr, updateComments)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) std::cout << "Tenant user updated successfully\n";
        else std::cout << "Update returned no data\n";
    } catch (const std::exception& ex) {
        std::cerr << "Update failed: " << ex.what() << '\n';
    }
});

createTenant

Параметри

Назив	Тип	Обавезно	Опис
tenantId	string	Да
createTenantBody	CreateTenantBody	Да

Одговор

Враћа: CreateTenant_200_response

Пример

Пример за createTenant

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateTenantBody createTenantBody;
createTenantBody.displayName = U("My Tenant Inc");
createTenantBody.adminEmail = U("admin@mytenant.com");
createTenantBody.plan = boost::optional<utility::string_t>(U("pro"));
auto task = api->createTenant(tenantId, createTenantBody)
    .then([](std::shared_ptr<CreateTenant_200_response> resp){
        if (resp){
            auto createdId = std::make_shared<utility::string_t>(resp->tenantId);
        }
    });
task.wait();

deleteTenant

Parametri

Ime	Tip	Obavezno
tenantId	string	Da
id	string	Da
sure	string	Ne

Odgovor

Vraća: FlagCommentPublic_200_response

Primjer

Primjer poziva deleteTenant

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("flag-456");
boost::optional<utility::string_t> sure = utility::string_t(U("true"));
api->deleteTenant(tenantId, id, sure)
    .then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> t) {
        try {
            auto resp = t.get();
            auto safeResp = resp ? resp : std::make_shared<FlagCommentPublic_200_response>();
            (void)safeResp;
        } catch (...) {}
    });

getTenant

Параметри

Име	Тип	Обавезно	Опис
tenantId	string	Да
id	string	Да

Одговор

Враћа: GetTenant_200_response

Пример

getTenant Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("admin@fastcomments.com");
boost::optional<utility::string_t> asOf = boost::optional<utility::string_t>(U("2026-01-01T00:00:00Z"));
api->getTenant(tenantId, id).then([asOf](pplx::task<std::shared_ptr<GetTenant_200_response>> t) {
    try {
        auto resp = t.get();
        if (!resp) return;
        auto processed = std::make_shared<GetTenant_200_response>(*resp);
    } catch (const std::exception&) {
    }
});

getTenants

Parametri

Name	Type	Required
tenantId	string	Da
meta	string	Ne
skip	double	Ne

Odgovor

Vraća: GetTenants_200_response

Primjer

getTenants Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> meta = boost::optional<utility::string_t>(U("admin@example.com"));
boost::optional<double> skip = boost::optional<double>(10.0);
auto task = api->getTenants(tenantId, meta, skip)
    .then([](std::shared_ptr<GetTenants_200_response> resp){
        if (resp) {
            auto copy = std::make_shared<GetTenants_200_response>(*resp);
        }
    });

updateTenant

Parametri

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

Odgovor

Vraća: FlagCommentPublic_200_response

Primjer

Primjer updateTenant

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto id = utility::string_t(U("tenant-0001"));
auto bodyPtr = std::make_shared<UpdateTenantBody>();
bodyPtr->setDisplayName(utility::string_t(U("Acme Corporation")));
bodyPtr->setAdminEmail(utility::string_t(U("admin@acme.com")));
bodyPtr->setIsActive(true);
bodyPtr->setMaxUsers(boost::optional<int>(250));
api->updateTenant(tenantId, id, *bodyPtr)
.then([](pplx::task<std::shared_ptr<FlagCommentPublic_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto msg = resp->getMessage();
            std::wcout << msg << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
});

changeTicketState

Параметри

Име	Тип	Обавезно
tenantId	string	Да
userId	string	Да
id	string	Да
changeTicketStateBody	ChangeTicketStateBody	Да

Одговор

Враћа: ChangeTicketState_200_response

Пример

Пример changeTicketState

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("agent@example.com");
utility::string_t id = U("TICKET-456");
auto changeBody = std::make_shared<ChangeTicketStateBody>();
changeBody->state = U("resolved");
changeBody->comment = U("Resolved as duplicate after review");
changeBody->notify = boost::optional<bool>(true);
api->changeTicketState(tenantId, userId, id, *changeBody)
.then([](pplx::task<std::shared_ptr<ChangeTicketState_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) {
            auto copy = std::make_shared<ChangeTicketState_200_response>(*resp);
        }
    } catch (const std::exception&) {}
});

createTicket

Parametri

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

Odgovor

Vraća: CreateTicket_200_response

Primjer

Primjer createTicket

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user@example.com");
auto bodyPtr = std::make_shared<CreateTicketBody>();
bodyPtr->subject = U("Comments not posting on article");
bodyPtr->message = U("Submitting a comment returns 200 but it does not appear for other users");
bodyPtr->priority = boost::optional<utility::string_t>(U("low"));
api->createTicket(tenantId, userId, *bodyPtr)
.then([](pplx::task<std::shared_ptr<CreateTicket_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto created = resp;
        }
    } catch (const std::exception& e) {
        (void)e;
    }
});

getTicket

Parametri

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

Odgovor

Vraća: GetTicket_200_response

Primjer

Primjer getTicket

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t ticketId = U("ticket-456");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
api->getTicket(tenantId, ticketId, userId)
.then([](pplx::task<std::shared_ptr<GetTicket_200_response>> t) {
    try {
        auto resp = t.get();
        auto wrapped = std::make_shared<std::shared_ptr<GetTicket_200_response>>(resp);
        if (*wrapped) {
            std::cout << "Ticket retrieved\n";
        } else {
            std::cout << "No ticket\n";
        }
    } catch (const std::exception &e) {
        std::cerr << "Error: " << e.what() << '\n';
    }
});

getTickets

Параметри

Назив	Тип	Обавезно
tenantId	string	Да
userId	string	Не
state	double	Не
skip	double	Не
limit	double	Не

Одговор

Враћа: GetTickets_200_response

Примјер

getTickets Примјер

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<double> state = boost::optional<double>(1.0);
boost::optional<double> skip = boost::optional<double>(0.0);
boost::optional<double> limit = boost::optional<double>(50.0);
api->getTickets(tenantId, userId, state, skip, limit)
.then([](pplx::task<std::shared_ptr<GetTickets_200_response>> t){
    try {
        auto resp = t.get();
        auto copy = std::make_shared<GetTickets_200_response>(*resp);
        std::cout << "Retrieved tickets: " << (resp ? "non-null" : "null") << std::endl;
    } catch (const std::exception &e) {
        std::cerr << "getTickets failed: " << e.what() << std::endl;
    }
});

uploadImage

Отпреми и промијени величину слике

Параметри

Име	Тип	Обавезно
tenantId	string	Да
file	HttpContent	Да
sizePreset	SizePreset	Не
urlId	string	Не

Одговор

Враћа: UploadImageResponse

Примјер

uploadImage Примјер

Copy

utility::string_t tenantId = U("my-tenant-123");
auto fileBytes = std::vector<unsigned char>{0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A};
auto file = std::make_shared<HttpContent>(fileBytes, U("image/png"), U("avatar.png"));
boost::optional<SizePreset> sizePreset = boost::optional<SizePreset>(SizePreset::MEDIUM);
boost::optional<utility::string_t> urlId = boost::optional<utility::string_t>(U("user-avatar-987"));
api->uploadImage(tenantId, file, sizePreset, urlId)
    .then([](pplx::task<std::shared_ptr<UploadImageResponse>> task) {
        try {
            return task.get();
        } catch (...) {
            return std::shared_ptr<UploadImageResponse>();
        }
    });

getUserBadgeProgressById

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: GetUserBadgeProgressById_200_response

Primjer

Primjer za getUserBadgeProgressById

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("badge-abc-456");
boost::optional<utility::string_t> preferredLocale = boost::optional<utility::string_t>(U("en-US"));
api->getUserBadgeProgressById(tenantId, id)
.then([=](std::shared_ptr<GetUserBadgeProgressById_200_response> resp){
    if(!resp) return;
    auto copy = std::make_shared<GetUserBadgeProgressById_200_response>(*resp);
    (void)copy;
});

getUserBadgeProgressByUserId

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Da
userId	string	Da

Odgovor

Vraća: GetUserBadgeProgressById_200_response

Primjer

getUserBadgeProgressByUserId Primjer

Copy

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

getUserBadgeProgressList

Параметри

Име	Тип	Обавезно
tenantId	string	Да
userId	string	Не
limit	double	Не
skip	double	Не

Одговор

Враћа: GetUserBadgeProgressList_200_response

Пример

getUserBadgeProgressList Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<double> limit = boost::optional<double>(50);
boost::optional<double> skip = boost::optional<double>(0);
api->getUserBadgeProgressList(tenantId, userId, limit, skip)
.then([](pplx::task<std::shared_ptr<GetUserBadgeProgressList_200_response>> t){
    try {
        auto resp = t.get();
        auto copied = std::make_shared<GetUserBadgeProgressList_200_response>(*resp);
        std::cout << "Badge progress entries received\n";
    } catch (const std::exception &e) {
        std::cerr << "Failed to get badge progress: " << e.what() << '\n';
    }
});

createUserBadge

Параметри

Назив	Тип	Обавезно	Опис
tenantId	string	Да
createUserBadgeParams	CreateUserBadgeParams	Да

Одговор

Враћа: CreateUserBadge_200_response

Пример

Пример createUserBadge

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateUserBadgeParams params;
params.userId = U("user@example.com");
params.badgeId = U("trusted-contributor");
params.note = boost::optional<utility::string_t>(U("Awarded for outstanding moderation"));
api->createUserBadge(tenantId, params)
.then([](std::shared_ptr<CreateUserBadge_200_response> resp){
    if (resp) {
        auto copied = std::make_shared<CreateUserBadge_200_response>(*resp);
    }
})
.wait();

deleteUserBadge

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: UpdateUserBadge_200_response

Primjer

deleteUserBadge Primjer

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
utility::string_t badgeId = utility::conversions::to_string_t("badge-456");
boost::optional<utility::string_t> traceId = boost::none;
api->deleteUserBadge(tenantId, badgeId)
.then([traceId](pplx::task<std::shared_ptr<UpdateUserBadge_200_response>> t) {
    try {
        auto resp = t.get();
        if (!resp) resp = std::make_shared<UpdateUserBadge_200_response>();
        return resp;
    } catch (const std::exception&) {
        return std::shared_ptr<UpdateUserBadge_200_response>();
    }
});

getUserBadge

Параметри

Име	Тип	Обавезно	Опис
tenantId	string	Да
id	string	Да

Одговор

Враћа: GetUserBadge_200_response

Пример

getUserBadge Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("user@example.com");
boost::optional<utility::string_t> traceId = U("trace-456");
api->getUserBadge(tenantId, id).then([traceId](std::shared_ptr<GetUserBadge_200_response> resp) {
    if (!resp) resp = std::make_shared<GetUserBadge_200_response>();
    utility::string_t activeTrace = traceId.value_or(U(""));
    (void)activeTrace;
    return resp;
});

getUserBadges

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
userId	string	Ne
badgeId	string	Ne
type	double	Ne
displayedOnComments	bool	Ne
limit	double	Ne
skip	double	Ne

Odgovor

Vraća: GetUserBadges_200_response

Primjer

Primjer getUserBadges

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> userId(utility::conversions::to_string_t("user@example.com"));
boost::optional<utility::string_t> badgeId(utility::conversions::to_string_t("badge-elite"));
boost::optional<double> type(1.0);
boost::optional<bool> displayedOnComments(true);
boost::optional<double> limit(50.0);
boost::optional<double> skip(0.0);
auto resultHolder = std::make_shared<GetUserBadges_200_response>();
api->getUserBadges(tenantId, userId, badgeId, type, displayedOnComments, limit, skip)
.then([&resultHolder](std::shared_ptr<GetUserBadges_200_response> resp){
    if (resp) resultHolder = resp;
    return resultHolder;
});

updateUserBadge

Parametri

Name	Type	Required
tenantId	string	Da
id	string	Da
updateUserBadgeParams	UpdateUserBadgeParams	Da

Odgovor

Vraća: UpdateUserBadge_200_response

Primjer

Primjer updateUserBadge

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("user@example.com");
UpdateUserBadgeParams updateParams;
updateParams.badgeId = U("badge-top-100");
updateParams.label = U("Top Contributor");
updateParams.active = boost::optional<bool>(true);
updateParams.expiresAt = boost::optional<utility::string_t>(U("2026-12-31T23:59:59Z"));
api->updateUserBadge(tenantId, id, updateParams)
.then([](pplx::task<std::shared_ptr<UpdateUserBadge_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto result = std::make_shared<UpdateUserBadge_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

getUserNotificationCount

Параметри

Име	Тип	Обавезно	Опис
tenantId	string	Да
sso	string	Не

Одговор

Враћа: GetUserNotificationCount_200_response

Пример

getUserNotificationCount Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
std::shared_ptr<GetUserNotificationCount_200_response> result;
api->getUserNotificationCount(tenantId, sso)
.then([&result](pplx::task<std::shared_ptr<GetUserNotificationCount_200_response>> t) {
    try {
        result = t.get();
        if (!result) result = std::make_shared<GetUserNotificationCount_200_response>();
    } catch (...) {
        result = std::make_shared<GetUserNotificationCount_200_response>();
    }
}).wait();

getUserNotifications

Параметри

Назив	Тип	Обавезно
tenantId	string	Да
pageSize	int32_t	Не
afterId	string	Не
includeContext	bool	Не
afterCreatedAt	int64_t	Не
unreadOnly	bool	Не
dmOnly	bool	Не
noDm	bool	Не
includeTranslations	bool	Не
sso	string	Не

Одговор

Враћа: GetUserNotifications_200_response

Пример

getUserNotifications Пример

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<int32_t> pageSize = 50;
boost::optional<utility::string_t> afterId = utility::conversions::to_string_t("notif_98765");
boost::optional<bool> includeContext = true;
boost::optional<int64_t> afterCreatedAt = static_cast<int64_t>(1672531200);
boost::optional<bool> unreadOnly = true;
boost::optional<bool> dmOnly = false;
boost::optional<bool> noDm = false;
boost::optional<bool> includeTranslations = true;
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("user@example.com");
api->getUserNotifications(tenantId, pageSize, afterId, includeContext, afterCreatedAt, unreadOnly, dmOnly, noDm, includeTranslations, sso)
.then([](pplx::task<std::shared_ptr<GetUserNotifications_200_response>> task){
    try {
        auto resp = task.get();
        auto copy = std::make_shared<GetUserNotifications_200_response>(*resp);
        return copy;
    } catch (...) {
        return std::shared_ptr<GetUserNotifications_200_response>();
    }
});

resetUserNotificationCount

Параметри

Име	Тип	Потребно	Опис
tenantId	string	Да
sso	string	Не

Одговор

Враћа: ResetUserNotifications_200_response

Пример

resetUserNotificationCount Пример

Copy

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

resetUserNotifications

Параметри

Име	Тип	Обавезно
tenantId	string	Да
afterId	string	Не
afterCreatedAt	int64_t	Не
unreadOnly	bool	Не
dmOnly	bool	Не
noDm	bool	Не
sso	string	Не

Одговор

Враћа: ResetUserNotifications_200_response

Пример

resetUserNotifications Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> afterId = boost::optional<utility::string_t>(U("notif-987654321"));
boost::optional<int64_t> afterCreatedAt = boost::optional<int64_t>(1625097600000LL);
boost::optional<bool> unreadOnly = boost::optional<bool>(true);
boost::optional<bool> dmOnly = boost::optional<bool>(false);
boost::optional<bool> noDm;
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
api->resetUserNotifications(tenantId, afterId, afterCreatedAt, unreadOnly, dmOnly, noDm, sso)
    .then([](pplx::task<std::shared_ptr<ResetUserNotifications_200_response>> t)
    {
        try
        {
            auto resp = t.get();
            auto respCopy = std::make_shared<ResetUserNotifications_200_response>(*resp);
            return respCopy;
        }
        catch (...)
        {
            return std::shared_ptr<ResetUserNotifications_200_response>();
        }
    });

updateUserNotificationCommentSubscriptionStatus

Omogućite ili onemogućite obavještenja za određeni komentar.

Parametri

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

Odgovor

Vraća: UpdateUserNotificationStatus_200_response

Primjer

Primjer updateUserNotificationCommentSubscriptionStatus

Copy

utility::string_t tenantId = utility::string_t(U("my-tenant-123"));
utility::string_t notificationId = utility::string_t(U("notif-789"));
utility::string_t optedInOrOut = utility::string_t(U("opted_in"));
utility::string_t commentId = utility::string_t(U("cmt-456"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(utility::string_t(U("user@example.com")));
api->updateUserNotificationCommentSubscriptionStatus(tenantId, notificationId, optedInOrOut, commentId, sso)
.then([](pplx::task<std::shared_ptr<UpdateUserNotificationStatus_200_response>> t){
    try {
        auto resp = t.get();
        auto result = resp ? resp : std::make_shared<UpdateUserNotificationStatus_200_response>();
    } catch (const std::exception&) {}
});

updateUserNotificationPageSubscriptionStatus

Omogućite ili onemogućite obavještenja za stranicu. Kada su korisnici pretplaćeni na stranicu, obavještenja se kreiraju za nove glavne komentare, i također

Parametri

Name	Type	Required
tenantId	string	Da
urlId	string	Da
url	string	Da
pageTitle	string	Da
subscribedOrUnsubscribed	string	Da
sso	string	Ne

Odgovor

Vraća: UpdateUserNotificationStatus_200_response

Primjer

updateUserNotificationPageSubscriptionStatus Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("page-456");
utility::string_t url = U("https://www.example.com/articles/2026/new-feature");
utility::string_t pageTitle = U("New Feature Announcement");
utility::string_t subscribedOrUnsubscribed = U("subscribed");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
auto placeholder = std::make_shared<UpdateUserNotificationStatus_200_response>();
api->updateUserNotificationPageSubscriptionStatus(tenantId, urlId, url, pageTitle, subscribedOrUnsubscribed, sso)
.then([](pplx::task<std::shared_ptr<UpdateUserNotificationStatus_200_response>> task){
    try {
        auto resp = task.get();
        (void)resp;
    } catch (const std::exception &e) {
        (void)e;
    }
});

updateUserNotificationStatus

Parametri

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

Odgovor

Vraća: UpdateUserNotificationStatus_200_response

Primjer

Primjer updateUserNotificationStatus

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t notificationId = U("notification-789");
utility::string_t newStatus = U("read");
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-token-abc123"));
api->updateUserNotificationStatus(tenantId, notificationId, newStatus, sso)
.then([](pplx::task<std::shared_ptr<UpdateUserNotificationStatus_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto result = std::make_shared<UpdateUserNotificationStatus_200_response>(*resp);
        }
    } catch (...) {
    }
});

getUserPresenceStatuses

Parametri

Ime	Tip	Obavezno
tenantId	string	Da
urlIdWS	string	Da
userIds	string	Da

Odgovor

Vraća: GetUserPresenceStatuses_200_response

Primjer

getUserPresenceStatuses Primjer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlIdWS = U("wss://realtime.fastcomments.com/socket/tenant-abc");
boost::optional<utility::string_t> optUserIds = U("alice@example.com,bob@example.com");
utility::string_t userIds = optUserIds.value_or(U("alice@example.com"));
auto task = api->getUserPresenceStatuses(tenantId, urlIdWS, userIds)
    .then([](std::shared_ptr<GetUserPresenceStatuses_200_response> resp) {
        if (!resp) return;
        auto copy = std::make_shared<GetUserPresenceStatuses_200_response>(*resp);
    });
task.wait();

searchUsers

Параметри

Назив	Тип	Обавезно
tenantId	string	Да
urlId	string	Да
usernameStartsWith	string	Не
mentionGroupIds	vector<string	Не
sso	string	Не
searchSection	string	Не

Одговор

Враћа: SearchUsers_200_response

Пример

Пример за searchUsers

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("/articles/2026/fast-comments-integration");
boost::optional<utility::string_t> usernameStartsWith = boost::optional<utility::string_t>(U("alex"));
std::vector<utility::string_t> groupsVec = { U("editors"), U("contributors") };
boost::optional<std::vector<utility::string_t>> mentionGroupIds = boost::optional<std::vector<utility::string_t>>(groupsVec);
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("sso-user-456"));
boost::optional<utility::string_t> searchSection = boost::optional<utility::string_t>(U("discussion"));
api->searchUsers(tenantId, urlId, usernameStartsWith, mentionGroupIds, sso, searchSection)
    .then([](pplx::task<std::shared_ptr<SearchUsers_200_response>> task) {
        try {
            auto resp = task.get();
            auto respCopy = std::make_shared<SearchUsers_200_response>(*resp);
            (void)respCopy;
        } catch (const std::exception&) {
        }
    });

getUser

Parametri

Ime	Tip	Obavezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vraća: GetUser_200_response

Primjer

getUser Primjer

Copy

boost::optional<utility::string_t> tenant(U("my-tenant-123"));
boost::optional<utility::string_t> userId(U("user@example.com"));
api->getUser(tenant.value(), userId.value())
    .then([](pplx::task<std::shared_ptr<GetUser_200_response>> task) {
        try {
            auto resp = task.get();
            if (resp) {
                auto result_copy = std::make_shared<GetUser_200_response>(*resp);
            } else {
                auto fallback = std::make_shared<GetUser_200_response>();
            }
        } catch (const std::exception &e) {
        }
    });

createVote

Parametri

Naziv	Tip	Obavezno
tenantId	string	Da
commentId	string	Da
direction	string	Da
userId	string	Ne
anonUserId	string	Ne

Odgovor

Vraća: VoteComment_200_response

Primjer

Primjer createVote

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
utility::string_t direction = U("up");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
api->createVote(tenantId, commentId, direction, userId, boost::none)
.then([](pplx::task<std::shared_ptr<VoteComment_200_response>> task) {
    try {
        auto resp = task.get();
        if (!resp) resp = std::make_shared<VoteComment_200_response>();
    } catch (...) {}
});

deleteVote

Параметри

Name	Type	Required
tenantId	string	Да
id	string	Да
editKey	string	Не

Одговор

Враћа: DeleteCommentVote_200_response

Пример

deleteVote Пример

Copy

utility::string_t tenantId = utility::conversions::to_string_t("my-tenant-123");
utility::string_t voteId = utility::conversions::to_string_t("vote-98765");
boost::optional<utility::string_t> editKey = boost::optional<utility::string_t>(utility::conversions::to_string_t("user-edit-key-abc123"));
api->deleteVote(tenantId, voteId, editKey)
.then([](pplx::task<std::shared_ptr<DeleteCommentVote_200_response>> t){
    try {
        auto resp = t.get();
        auto result = resp ? std::make_shared<DeleteCommentVote_200_response>(*resp)
                           : std::make_shared<DeleteCommentVote_200_response>();
        (void)result;
    } catch (const std::exception& e) {
        (void)e;
    }
});

getVotes

Parametri

Naziv	Tip	Obavezno	Opis
tenantId	string	Da
urlId	string	Da

Odgovor

Vraća: GetVotes_200_response

Primjer

getVotes Primjer

Copy

boost::optional<utility::string_t> tenantId = utility::string_t(U("my-tenant-123"));
boost::optional<utility::string_t> urlId = utility::string_t(U("/posts/2025/new-features"));
auto task = api->getVotes(tenantId.value(), urlId.value()).then([](std::shared_ptr<GetVotes_200_response> resp){
    if (resp) {
        auto copy = std::make_shared<GetVotes_200_response>(*resp);
        std::cout << "Fetched votes successfully\n";
    } else {
        std::cout << "No votes response\n";
    }
});
task.wait();

getVotesForUser

Параметри

Име	Тип	Обавезно
tenantId	string	Да
urlId	string	Да
userId	string	Не
anonUserId	string	Не

Одговор

Враћа: GetVotesForUser_200_response

Пример

getVotesForUser Пример

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("article-987");
boost::optional<utility::string_t> userId = utility::string_t(U("user@example.com"));
boost::optional<utility::string_t> anonUserId;
api->getVotesForUser(tenantId, urlId, userId, anonUserId)
.then([](pplx::task<std::shared_ptr<GetVotesForUser_200_response>> task){
    try {
        auto resp = task.get();
        if (resp) {
            auto copy = std::make_shared<GetVotesForUser_200_response>(*resp);
        }
    } catch (const std::exception&) {
    }
});

Требате ли помоћ?

Ако наиђете на било какве проблеме или имате питања у вези са C++ SDK-ом, молимо вас:

Доприноси

Допринoси су добродошли! Молимо посетите GitHub репозиторијум за смернице о доприносу.

Језик 🇧🇦 Српски (БиХ)

Документација

Почетак

API референца

Употреба

Агрегација

Аудит записи

Блокирање по коментару

Провјери блокиране коментаре

Коментари

Конфигурације домена

Шаблони е-поште

Дневник догађаја

Објаве фида

Пријави коментар

Хештегови

Модератори

Број обавијести

Обавијести

Странице

Очекујући вебхук догађаји

Конфигурације питања

Резултати питања

Агрегација резултата питања

SSO корисници

Претплате

Дневна употреба тенанта

Пакети тенанта

Корисници тенанта

Тенанти

Тикети

Отпремање слике

Напредак ознаке корисника

Ознаке корисника

Обавијести корисника

Статус присутности корисника

Претрага корисника

Корисници

Гласови

FastComments C++ SDK

Репозиторијум

Захтјеви

Инсталација

Instalirajte zavisnosti

Kompiliranje iz izvornog koda

Instaliranje

Sadržaj biblioteke

Javni i zaštićeni API-ji

Брзи почетак

Коришћење аутентификованих API-ја (DefaultAPI)

Коришћење јавних API-ја (PublicAPI)

Чести проблеми

Извршавање API позива: синхроно и асинхроно

Sinhroni pozivi sa .get()

Asinhroni pozivi sa .then()

Izbor između sinhronog i asinhronog

Напомене

ИД-ови емитовања

SSO (Једнократна пријава)

Коришћење SSO

Једноставан SSO

Сигуран SSO

Документација за fastcomments

Документација за API крајње тачке

Документација за Моделе

Агрегација

Параметри

Одговор

Пример

getAuditLogs

Parametri

Odgovor

Primjer

blockFromCommentPublic

Parametri

Odgovor

Primjer

unBlockCommentPublic

Параметри

Одговор

Sinhroni pozivi sa `.get()`

Asinhroni pozivi sa `.then()`