FastComments SDK za C++

To je uradni C++ SDK za FastComments.

Uradni C++ SDK za API FastComments

Repozitorij

Zahteve

C++17 ali novejša
CMake 3.14 ali novejša
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (samodejno prenesen za testiranje)

Namestitev

Namestitev odvisnosti

sudo apt install libcpprest-dev libboost-all-dev

Gradnja iz izvorne kode

mkdir build
cd build
cmake ..
make

Namestitev

sudo make install

Vsebina knjižnice

Ta knjižnica vsebuje ustvarjen odjemalec API-ja in orodja SSO, ki olajšajo delo z API-jem.

API Client Library Docs

Javni in zavarovani API-ji

Za odjemalca API obstajajo trije razredi, DefaultApi, PublicApi in ModerationApi. DefaultApi vsebuje metode, ki zahtevajo vaš API ključ, PublicApi pa metode, ki jih je mogoče izvajati neposredno iz brskalnika/naprave mobilnega telefona/itd brez avtentikacije. ModerationApi nudi obsežen nabor živih in hitrih moderacijskih API-jev. Vsaka metoda ModerationApi sprejme parameter sso in se lahko avtenticira prek SSO ali piškotka seje FastComments.com.

Hitri začetek

Uporaba avtenticiranih API-jev (DefaultAPI)

Pomembno:

Morate nastaviti osnovni URL (cpp‑restsdk generator ga ne prebere iz OpenAPI specifikacije)
Morate nastaviti svoj API ključ v ApiClient pred izvedbo avtenticiranih zahtev. Če tega ne storite, bodo zahteve neuspešne z napako 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>();

    // OBVEZNO: Nastavi osnovni URL (izberi svojo regijo)
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));  // US
    // ALI: config->setBaseUrl(utility::conversions::to_string_t("https://eu.fastcomments.com"));  // EU

    // OBVEZNO: Nastavi svoj API ključ
    config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_API_KEY_HERE"));

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

    // Zdaj izvedi avtenticirane klice API
    return 0;
}

Uporaba javnih API-jev (PublicAPI)

Javni končni naslovi ne zahtevajo avtentikacije:

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

    // OBVEZNO: Nastavi osnovni URL
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

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

    // Izvedi javne klice API
    return 0;
}

Uporaba moderacijskih API-jev (ModerationApi)

ModerationApi poganja nadzorno ploščo moderatorjev. Vsaka metoda sprejme parameter sso, tako da se klic izvede v imenu moderatorja, avtenticiranega prek SSO (glejte sekcijo SSO spodaj za ustvarjanje žetona):

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

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

    // OBVEZNO: Nastavi osnovni URL
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

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

    // Posreduj SSO žeton moderatorja, da overiš klic
    auto ssoToken = utility::conversions::to_string_t("YOUR_MODERATOR_SSO_TOKEN");

    org::openapitools::client::api::GetCountOptions options;
    options.sso = ssoToken;

    auto response = moderationApi.getCount(options).get();

    return 0;
}

Pogoste težave

Napaka “URI must contain a hostname”: Prepričajte se, da pred ustvarjanjem ApiClient pokličete config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")). Generator cpp‑restsdk ne prebere samodejno URL‑ja strežnika iz OpenAPI specifikacije.
Napaka 401 “missing-api-key”: Prepričajte se, da pred ustvarjanjem instance DefaultAPI pokličete config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")).
Napačen API razred: Uporabite DefaultApi za strežniške avtenticirane zahteve, PublicApi za odjemalske/javne zahteve in ModerationApi za zahteve nadzorne plošče moderatorja (avtenticirane s SSO žetonom moderatorja).

Klici API: sinhroni proti asinhronim

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

Sinhroni klici z `.get()`

Use .get() to block the calling thread until the request completes and retrieve the result synchronously:

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

// Zahtevani parametri so pozicijski; neobvezni grejo v strukturo možnosti
org::openapitools::client::api::GetCommentsOptions options;
options.urlId = utility::conversions::to_string_t("your-url-id");

// Pokličite .get(), da blokirate in pridobite rezultat sinhrono
auto response = api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    options
).get();  // Blokira, dokler HTTP zahteva ne zaključi

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

Asinhroni klici z `.then()`

Use .then() for non-blocking asynchronous execution with callbacks:

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

// Zahtevani parametri so pozicijski; neobvezni grejo v strukturo možnosti
org::openapitools::client::api::GetCommentsOptions options;
options.urlId = utility::conversions::to_string_t("your-url-id");

// Uporabite .then() za asinhrono izvajanje s povratnimi klici
api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    options
).then([](std::shared_ptr<GetComments_200_response> response) {
    // To se izvede asinhrono, ko se zahteva zaključi
    if (response && response->comments) {
        std::cout << "Found " << response->comments->size() << " comments" << std::endl;
    }
});

// Izvajanje se takoj nadaljuje brez blokiranja
std::cout << "Request sent, continuing..." << std::endl;

Izbira med sinhronim in asinhronim

The choice depends on your runtime environment and application architecture:

.get() (Synchronous blocking)

Blokira klicno nit, dokler HTTP zahteva ne zaključi
Preprostejši potek kode, lažje razumljiv
Primeren za namenjene delovne niti, paketna obdelovanja ali orodja v ukazni vrstici
Ni primerno za zanke dogodkov, GUI niti ali enovratne strežnike

.then() (Asynchronous non-blocking)

Vrne takoj, povratni klic se izvede, ko se zahteva zaključi
Ne blokira klicne niti
Potrebno za dogodkovno usmerjene arhitekture, GUI aplikacije ali enovratne zanke dogodkov
Omogoča zaporedno povezovanje več operacij
Bolj zapleten potek nadzora

The SDK's test suite uses .get() exclusively, but this is appropriate for the test environment where blocking is acceptable.

Opombe

Broadcast Ids

Videli boste, da morate v nekaterih klicih API posredovati broadcastId. Ko prejmete dogodke, boste dobili ta ID nazaj, tako da veste, da lahko dogodek ignorirate, če nameravate optimistično uporabiti spremembe na odjemalcu (kar boste verjetno želeli storiti, saj zagotavlja najboljšo izkušnjo). Posredujte UUID tukaj. ID naj bo dovolj edinstven, da se ne pojavi dvakrat v brskalniški seji.

SSO (Enotna prijava)

Za primere SSO glejte spodaj.

Uporaba SSO

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

Varen SSO

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

using namespace fastcomments::sso;

int main() {
    SecureSSOUserData user("user-123", "user@example.com", "johndoe", "https://example.com/avatar.jpg");

    std::string apiKey = "your-api-key";
    FastCommentsSSO sso = FastCommentsSSO::newSecure(apiKey, user);
    std::string token = sso.createToken();

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

Dokumentacija za fastcomments

Dokumentacija za API končne točke

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

Klasa	Metoda	HTTP zahteva	Opis
DefaultApi	addDomainConfig	POST /api/v1/domain-configs
DefaultApi	addHashTag	POST /api/v1/hash-tags
DefaultApi	addHashTagsBulk	POST /api/v1/hash-tags/bulk
DefaultApi	addPage	POST /api/v1/pages
DefaultApi	addSSOUser	POST /api/v1/sso-users
DefaultApi	aggregate	POST /api/v1/aggregate	Agregira dokumente z njihovim grupiranjem (če je naveden groupBy) in uporabo več operacij. Podprte so različne operacije (npr. 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	req tenantId afterId
DefaultApi	getHashTags	GET /api/v1/hash-tags
DefaultApi	getModerator	GET /api/v1/moderators/{id}
DefaultApi	getModerators	GET /api/v1/moderators
DefaultApi	getNotificationCount	GET /api/v1/notifications/count
DefaultApi	getNotifications	GET /api/v1/notifications
DefaultApi	getPageByURLId	GET /api/v1/pages/by-url-id
DefaultApi	getPages	GET /api/v1/pages
DefaultApi	getPendingWebhookEventCount	GET /api/v1/pending-webhook-events/count
DefaultApi	getPendingWebhookEvents	GET /api/v1/pending-webhook-events
DefaultApi	getQuestionConfig	GET /api/v1/question-configs/{id}
DefaultApi	getQuestionConfigs	GET /api/v1/question-configs
DefaultApi	getQuestionResult	GET /api/v1/question-results/{id}
DefaultApi	getQuestionResults	GET /api/v1/question-results
DefaultApi	getSSOUserByEmail	GET /api/v1/sso-users/by-email/{email}
DefaultApi	getSSOUserById	GET /api/v1/sso-users/by-id/{id}
DefaultApi	getSSOUsers	GET /api/v1/sso-users
DefaultApi	getSubscriptions	GET /api/v1/subscriptions
DefaultApi	getTenant	GET /api/v1/tenants/{id}
DefaultApi	getTenantDailyUsages	GET /api/v1/tenant-daily-usage
DefaultApi	getTenantPackage	GET /api/v1/tenant-packages/{id}
DefaultApi	getTenantPackages	GET /api/v1/tenant-packages
DefaultApi	getTenantUser	GET /api/v1/tenant-users/{id}
DefaultApi	getTenantUsers	GET /api/v1/tenant-users
DefaultApi	getTenants	GET /api/v1/tenants
DefaultApi	getTicket	GET /api/v1/tickets/{id}
DefaultApi	getTickets	GET /api/v1/tickets
DefaultApi	getUser	GET /api/v1/users/{id}
DefaultApi	getUserBadge	GET /api/v1/user-badges/{id}
DefaultApi	getUserBadgeProgressById	GET /api/v1/user-badge-progress/{id}
DefaultApi	getUserBadgeProgressByUserId	GET /api/v1/user-badge-progress/user/{userId}
DefaultApi	getUserBadgeProgressList	GET /api/v1/user-badge-progress
DefaultApi	getUserBadges	GET /api/v1/user-badges
DefaultApi	getVotes	GET /api/v1/votes
DefaultApi	getVotesForUser	GET /api/v1/votes/for-user
DefaultApi	patchDomainConfig	PATCH /api/v1/domain-configs/{domainToUpdate}
DefaultApi	patchHashTag	PATCH /api/v1/hash-tags/{tag}
DefaultApi	patchPage	PATCH /api/v1/pages/{id}
DefaultApi	patchSSOUser	PATCH /api/v1/sso-users/{id}
DefaultApi	putDomainConfig	PUT /api/v1/domain-configs/{domainToUpdate}
DefaultApi	putSSOUser	PUT /api/v1/sso-users/{id}
DefaultApi	renderEmailTemplate	POST /api/v1/email-templates/render
DefaultApi	replaceTenantPackage	PUT /api/v1/tenant-packages/{id}
DefaultApi	replaceTenantUser	PUT /api/v1/tenant-users/{id}
DefaultApi	saveComment	POST /api/v1/comments
DefaultApi	saveCommentsBulk	POST /api/v1/comments/bulk
DefaultApi	sendInvite	POST /api/v1/moderators/{id}/send-invite
DefaultApi	sendLoginLink	POST /api/v1/tenant-users/{id}/send-login-link
DefaultApi	unBlockUserFromComment	POST /api/v1/comments/{id}/un-block
DefaultApi	unFlagComment	POST /api/v1/comments/{id}/un-flag
DefaultApi	updateComment	PATCH /api/v1/comments/{id}
DefaultApi	updateEmailTemplate	PATCH /api/v1/email-templates/{id}
DefaultApi	updateFeedPost	PATCH /api/v1/feed-posts/{id}
DefaultApi	updateModerator	PATCH /api/v1/moderators/{id}
DefaultApi	updateNotification	PATCH /api/v1/notifications/{id}
DefaultApi	updateQuestionConfig	PATCH /api/v1/question-configs/{id}
DefaultApi	updateQuestionResult	PATCH /api/v1/question-results/{id}
DefaultApi	updateSubscription	PATCH /api/v1/subscriptions/{id}
DefaultApi	updateTenant	PATCH /api/v1/tenants/{id}
DefaultApi	updateTenantPackage	PATCH /api/v1/tenant-packages/{id}
DefaultApi	updateTenantUser	PATCH /api/v1/tenant-users/{id}
DefaultApi	updateUserBadge	PUT /api/v1/user-badges/{id}
ModerationApi	deleteModerationVote	DELETE /auth/my-account/moderate-comments/mod_api/vote/{commentId}/{voteId}
ModerationApi	getApiComments	GET /auth/my-account/moderate-comments/mod_api/api/comments
ModerationApi	getApiExportStatus	GET /auth/my-account/moderate-comments/mod_api/api/export/status
ModerationApi	getApiIds	GET /auth/my-account/moderate-comments/mod_api/api/ids
ModerationApi	getBanUsersFromComment	GET /auth/my-account/moderate-comments/mod_api/ban-users/from-comment/{commentId}
ModerationApi	getCommentBanStatus	GET /auth/my-account/moderate-comments/mod_api/get-comment-ban-status/{commentId}
ModerationApi	getCommentChildren	GET /auth/my-account/moderate-comments/mod_api/comment-children/{commentId}
ModerationApi	getCount	GET /auth/my-account/moderate-comments/mod_api/count
ModerationApi	getCounts	GET /auth/my-account/moderate-comments/banned-users/mod_api/counts
ModerationApi	getLogs	GET /auth/my-account/moderate-comments/mod_api/logs/{commentId}
ModerationApi	getManualBadges	GET /auth/my-account/moderate-comments/mod_api/get-manual-badges
ModerationApi	getManualBadgesForUser	GET /auth/my-account/moderate-comments/mod_api/get-manual-badges-for-user
ModerationApi	getModerationComment	GET /auth/my-account/moderate-comments/mod_api/comment/{commentId}
ModerationApi	getModerationCommentText	GET /auth/my-account/moderate-comments/mod_api/get-comment-text/{commentId}
ModerationApi	getPreBanSummary	GET /auth/my-account/moderate-comments/mod_api/pre-ban-summary/{commentId}
ModerationApi	getSearchCommentsSummary	GET /auth/my-account/moderate-comments/mod_api/search/comments/summary
ModerationApi	getSearchPages	GET /auth/my-account/moderate-comments/mod_api/search/pages
ModerationApi	getSearchSites	GET /auth/my-account/moderate-comments/mod_api/search/sites
ModerationApi	getSearchSuggest	GET /auth/my-account/moderate-comments/mod_api/search/suggest
ModerationApi	getSearchUsers	GET /auth/my-account/moderate-comments/mod_api/search/users
ModerationApi	getTrustFactor	GET /auth/my-account/moderate-comments/mod_api/get-trust-factor
ModerationApi	getUserBanPreference	GET /auth/my-account/moderate-comments/mod_api/user-ban-preference
ModerationApi	getUserInternalProfile	GET /auth/my-account/moderate-comments/mod_api/get-user-internal-profile
ModerationApi	postAdjustCommentVotes	POST /auth/my-account/moderate-comments/mod_api/adjust-comment-votes/{commentId}
ModerationApi	postApiExport	POST /auth/my-account/moderate-comments/mod_api/api/export
ModerationApi	postBanUserFromComment	POST /auth/my-account/moderate-comments/mod_api/ban-user/from-comment/{commentId}
ModerationApi	postBanUserUndo	POST /auth/my-account/moderate-comments/mod_api/ban-user/undo
ModerationApi	postBulkPreBanSummary	POST /auth/my-account/moderate-comments/mod_api/bulk-pre-ban-summary
ModerationApi	postCommentsByIds	POST /auth/my-account/moderate-comments/mod_api/comments-by-ids
ModerationApi	postFlagComment	POST /auth/my-account/moderate-comments/mod_api/flag-comment/{commentId}
ModerationApi	postRemoveComment	POST /auth/my-account/moderate-comments/mod_api/remove-comment/{commentId}
ModerationApi	postRestoreDeletedComment	POST /auth/my-account/moderate-comments/mod_api/restore-deleted-comment/{commentId}
ModerationApi	postSetCommentApprovalStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-approval-status/{commentId}
ModerationApi	postSetCommentReviewStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-review-status/{commentId}
ModerationApi	postSetCommentSpamStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-spam-status/{commentId}
ModerationApi	postSetCommentText	POST /auth/my-account/moderate-comments/mod_api/set-comment-text/{commentId}
ModerationApi	postUnFlagComment	POST /auth/my-account/moderate-comments/mod_api/un-flag-comment/{commentId}
ModerationApi	postVote	POST /auth/my-account/moderate-comments/mod_api/vote/{commentId}
ModerationApi	putAwardBadge	PUT /auth/my-account/moderate-comments/mod_api/award-badge
ModerationApi	putCloseThread	PUT /auth/my-account/moderate-comments/mod_api/close-thread
ModerationApi	putRemoveBadge	PUT /auth/my-account/moderate-comments/mod_api/remove-badge
ModerationApi	putReopenThread	PUT /auth/my-account/moderate-comments/mod_api/reopen-thread
ModerationApi	setTrustFactor	PUT /auth/my-account/moderate-comments/mod_api/set-trust-factor
PublicApi	blockFromCommentPublic	POST /block-from-comment/{commentId}
PublicApi	checkedCommentsForBlocked	GET /check-blocked-comments
PublicApi	createCommentPublic	POST /comments/{tenantId}
PublicApi	createFeedPostPublic	POST /feed-posts/{tenantId}
PublicApi	createV1PageReact	POST /page-reacts/v1/likes/{tenantId}
PublicApi	createV2PageReact	POST /page-reacts/v2/{tenantId}
PublicApi	deleteCommentPublic	DELETE /comments/{tenantId}/{commentId}
PublicApi	deleteCommentVote	DELETE /comments/{tenantId}/{commentId}/vote/{voteId}
PublicApi	deleteFeedPostPublic	DELETE /feed-posts/{tenantId}/{postId}
PublicApi	deleteV1PageReact	DELETE /page-reacts/v1/likes/{tenantId}
PublicApi	deleteV2PageReact	DELETE /page-reacts/v2/{tenantId}
PublicApi	flagCommentPublic	POST /flag-comment/{commentId}
PublicApi	getCommentText	GET /comments/{tenantId}/{commentId}/text
PublicApi	getCommentVoteUserNames	GET /comments/{tenantId}/{commentId}/votes
PublicApi	getCommentsForUser	GET /comments-for-user
PublicApi	getCommentsPublic	GET /comments/{tenantId}	req tenantId urlId
PublicApi	getEventLog	GET /event-log/{tenantId}	req tenantId urlId userIdWS
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	req tenantId afterId
PublicApi	getFeedPostsStats	GET /feed-posts/{tenantId}/stats
PublicApi	getGifLarge	GET /gifs/get-large/{tenantId}
PublicApi	getGifsSearch	GET /gifs/search/{tenantId}
PublicApi	getGifsTrending	GET /gifs/trending/{tenantId}
PublicApi	getGlobalEventLog	GET /event-log/global/{tenantId}	req tenantId urlId userIdWS
PublicApi	getOfflineUsers	GET /pages/{tenantId}/users/offline	Prejšnji komentatorji na strani, KI NISO trenutno online. Razvrščeni po displayName. Uporabite po izčrpavanju `/users/online`, da prikažete razdelek “Člani”. Kursorska paginacija po commenterName: strežnik sprehaja delni indeks `{tenantId, urlId, commenterName}` od afterName naprej z `$gt`, brez stroška `$skip`.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	Trenutno‑online gledalci strani: ljudje, katerih WebSocket seja je trenutno naročena na stran. Vrne anonCount + totalCount (vsi naročniki sobe, vključno z anonimnimi gledalci, ki jih ne naštejemo).
PublicApi	getPagesPublic	GET /pages/{tenantId}	Seznam strani za najemnika. Uporablja ga namizni odjemalec FChat za napolnitev seznama sob. Zahteva, da je `enableFChat` nastavljeno na true v razrešenem prilagojenem nastavitvenem objektu za vsako stran. Strani, ki zahtevajo SSO, so filtrirane glede na grupni dostop zahtevajočega uporabnika.
PublicApi	getTranslations	GET /translations/{namespace}/{component}
PublicApi	getUserNotificationCount	GET /user-notifications/get-count
PublicApi	getUserNotifications	GET /user-notifications
PublicApi	getUserPresenceStatuses	GET /user-presence-status
PublicApi	getUserReactsPublic	GET /feed-posts/{tenantId}/user-reacts
PublicApi	getUsersInfo	GET /pages/{tenantId}/users/info	Paketirani podatki o uporabnikih za najemnika. Podan seznam userIds vrne prikazne podatke iz User / SSOUser. Uporablja widget za komentarje, da obogati uporabnike, ki se pravkar pojavijo preko dogodka prisotnosti. Brez kontekstne strani: zasebni profili so maskirani, da se ohrani zasebnost.
PublicApi	getV1PageLikes	GET /page-reacts/v1/likes/{tenantId}
PublicApi	getV2PageReactUsers	GET /page-reacts/v2/{tenantId}/list
PublicApi	getV2PageReacts	GET /page-reacts/v2/{tenantId}
PublicApi	lockComment	POST /comments/{tenantId}/{commentId}/lock
PublicApi	logoutPublic	PUT /auth/logout
PublicApi	pinComment	POST /comments/{tenantId}/{commentId}/pin
PublicApi	reactFeedPostPublic	POST /feed-posts/{tenantId}/react/{postId}
PublicApi	resetUserNotificationCount	POST /user-notifications/reset-count
PublicApi	resetUserNotifications	POST /user-notifications/reset
PublicApi	searchUsers	GET /user-search/{tenantId}
PublicApi	setCommentText	POST /comments/{tenantId}/{commentId}/update-text
PublicApi	unBlockCommentPublic	DELETE /block-from-comment/{commentId}
PublicApi	unLockComment	POST /comments/{tenantId}/{commentId}/unlock
PublicApi	unPinComment	POST /comments/{tenantId}/{commentId}/unpin
PublicApi	updateFeedPostPublic	PUT /feed-posts/{tenantId}/{postId}
PublicApi	updateUserNotificationCommentSubscriptionStatus	POST /user-notifications/{notificationId}/mark-opted/{optedInOrOut}	Omogoči ali onemogoči obvestila za določen komentar.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Omogoči ali onemogoči obvestila za stran. Ko so uporabniki naročeni na stran, se ustvarijo obvestila za nove korenske komentarje, in tudi
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Naloži in spremeni velikost slike
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Dokumentacija za modele

aggregate

Aggregira dokumente z grupiranjem (če je podan parameter groupBy) in uporabo več operacij. Podprte so različne operacije (npr. sum, countDistinct, avg itd.).

Parameters

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

Response

Returns: AggregateResponse

Example

aggregate Primer

Copy

utility::string_t tenantId = U("my-tenant-123");
AggregationRequest aggregationRequest;
aggregationRequest.setMetric(U("commentCount"));
aggregationRequest.setStartDate(U("2023-01-01T00:00:00Z"));
aggregationRequest.setEndDate(U("2023-12-31T23:59:59Z"));
aggregationRequest.setFilters({ U("status:approved") });
AggregateOptions options;
options.limit = boost::optional<int>(100);
options.includeMetadata = boost::optional<bool>(true);
api->aggregate(tenantId, aggregationRequest, options)
    .then([](pplx::task<std::shared_ptr<AggregateResponse>> task) {
        try {
            auto response = task.get();
            // process response
        } catch (const std::exception& e) {
            // handle error
        }
    });

getAuditLogs

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
options	const GetAuditLogsOptions&	Yes

Odgovor

Vrne: GetAuditLogsResponse

Primer

getAuditLogs Primer

Copy

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

logoutPublic

Odgovor

Vrne: APIEmptyResponse

Primer

logoutPublic Primer

Copy

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

blockFromCommentPublic

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
commentId	string	Yes
publicBlockFromCommentParams	PublicBlockFromCommentParams	Yes
sso	string	No

Odgovor

Vrne: BlockSuccess

Primer

blockFromCommentPublic Primer

Copy

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

unBlockCommentPublic

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Da
commentId	string	Da
publicBlockFromCommentParams	PublicBlockFromCommentParams	Da
sso	string	Ne

Odgovor

Vrne: UnblockSuccess

Primer

unBlockCommentPublic Primer

Copy

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

checkedCommentsForBlocked

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
commentIds	string	Da
sso	string	Ne

Odgovor

Vrne: CheckBlockedCommentsResponse

Primer

checkedCommentsForBlocked Primer

Copy

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

blockUserFromComment

Parametri

Ime	Tip	Obvezno
tenantId	string	Yes
id	string	Yes
blockFromCommentParams	BlockFromCommentParams	Yes
options	const BlockUserFromCommentOptions&	Yes

Odgovor

Vrne: BlockSuccess

Primer

blockUserFromComment Primer

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-789");
BlockFromCommentParams params;
params.reason = utility::conversions::to_string_t("Inappropriate content");
params.durationDays = boost::optional<int>(30);
BlockUserFromCommentOptions options;
options.notifyUser = boost::optional<bool>(true);
api->blockUserFromComment(tenantId, commentId, params, options)
    .then([](std::shared_ptr<BlockSuccess> result){ })
    .then([](pplx::task<void> t){ try { t.get(); } catch (const std::exception&) { } });

createCommentPublic

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
commentData	CommentData	Yes
options	const CreateCommentPublicOptions&	Yes

Odgovor

Vrne: SaveCommentsResponseWithPresence

Primer

Primer createCommentPublic

Copy

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

deleteComment

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
id	string	Da
options	const DeleteCommentOptions&	Da

Odgovor

Returns: DeleteCommentResult

Primer

deleteComment Primer

Copy

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

deleteCommentPublic

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
commentId	string	Da
broadcastId	string	Da
options	const DeleteCommentPublicOptions&	Da

Odgovor

Vrne: PublicAPIDeleteCommentResponse

Primer

deleteCommentPublic Primer

Copy

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

deleteCommentVote

Parameters

Ime	Vrsta	Obvezno
tenantId	string	Yes
commentId	string	Yes
voteId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
options	const DeleteCommentVoteOptions&	Yes

Response

Vrne: VoteDeleteResponse

Primer

deleteCommentVote Primer

Copy

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

flagComment

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Da
id	string	Da
options	const FlagCommentOptions&	Da

Odgovor

Vrne: FlagCommentResponse

Primer

flagComment primer

Copy

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

getComment

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vrne: APIGetCommentResponse

Primer

Primer getComment

Copy

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

getComments

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
options	const GetCommentsOptions&	Da

Odgovor

Vrne: APIGetCommentsResponse

Primer

Primer getComments

Copy

utility::string_t tenantId = U("my-tenant-123");
GetCommentsOptions options;
options.page = 1;
options.limit = 50;
options.sort = U("newest");
options.authorEmail = boost::optional<utility::string_t>(U("user@example.com"));
api->getComments(tenantId, options).then([](pplx::task<std::shared_ptr<APIGetCommentsResponse>> task) {
    try {
        auto response = task.get();
        // uporabite odziv po potrebi
    } catch (const std::exception& e) {
        // obravnavajte napako
    }
});

getCommentsPublic

zahteva tenantId urlId

Parametri

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

Odgovor

Vrne: GetCommentsResponseWithPresence_PublicComment_

Primer

Primer getCommentsPublic

Copy

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

getCommentText

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
commentId	string	Da
options	const GetCommentTextOptions&	Da

Odgovor

Vrne: PublicAPIGetCommentTextResponse

Primer

Primer getCommentText

Copy

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

getCommentVoteUserNames

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
commentId	string	Da
dir	int32_t	Da
sso	string	Ne

Odgovor

Vrne: GetCommentVoteUserNamesSuccessResponse

Primer

Primer getCommentVoteUserNames

Copy

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

lockComment

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
commentId	string	Da
broadcastId	string	Da
sso	string	Ne

Odgovor

Vrne: APIEmptyResponse

Primer

lockComment Primer

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-987");
auto broadcastId = utility::conversions::to_string_t("broadcast-654");
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("sso-token-xyz");
api->lockComment(tenantId, commentId, broadcastId, sso).then([](pplx::task<std::shared_ptr<APIEmptyResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){
    }
});

pinComment

Parameters

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

Response

Vrne: ChangeCommentPinStatusResponse

Primer

pinComment Primer

Copy

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

saveComment

Parameters

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

Response

Vrne: APISaveCommentResponse

Example

saveComment Primer

Copy

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

setCommentText

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
commentTextUpdateRequest	CommentTextUpdateRequest	Yes
options	const SetCommentTextOptions&	Yes

Odgovor

Vrne: PublicAPISetCommentTextResponse

Primer

setCommentText Primer

Copy

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

unBlockUserFromComment

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
id	string	Da
unBlockFromCommentParams	UnBlockFromCommentParams	Da
options	const UnBlockUserFromCommentOptions&	Da

Odgovor

Vrne: UnblockSuccess

Primer

unBlockUserFromComment Primer

Copy

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

unFlagComment

Parametri

Ime	Tip	Potrebno
tenantId	string	Da
id	string	Da
options	const UnFlagCommentOptions&	Da

Odgovor

Vrne: FlagCommentResponse

Primer

unFlagComment Primer

Copy

auto options = UnFlagCommentOptions{};
options.reason = boost::optional<utility::string_t>(U("Resolved by moderator"));
api->unFlagComment(U("my-tenant-123"), U("comment-456"), options)
    .then([](std::shared_ptr<FlagCommentResponse> response) {
        if (response) {
            auto status = response->status;
            // process status if needed
        }
    })
    .then([](pplx::task<void> previous) {
        try {
            previous.get();
        } catch (const std::exception& e) {
            // handle error
        }
    });

unLockComment

Parameters

Ime	Tip	Obvezno
tenantId	string	Da
commentId	string	Da
broadcastId	string	Da
sso	string	Ne

Response

Vrne: APIEmptyResponse

Example

Primer unLockComment

Copy

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

unPinComment

Parametri

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

Odgovor

Vrne: ChangeCommentPinStatusResponse

Primer

Primer unPinComment

Copy

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

updateComment

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
id	string	Da
updatableCommentParams	UpdatableCommentParams	Da
options	const UpdateCommentOptions&	Da

Odgovor

Vrne: APIEmptyResponse

Primer

updateComment Primer

Copy

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

voteComment

Parameters

Ime	Tip	Obvezno
tenantId	string	Yes
commentId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
voteBodyParams	VoteBodyParams	Yes
options	const VoteCommentOptions&	Yes

Response

Vrne: VoteResponse

Example

voteComment Primer

Copy

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

getCommentsForUser

Parametri

Ime	Tip	Obvezno	Opis
options	const GetCommentsForUserOptions&	Yes

Odgovor

Vrne: GetCommentsForUserResponse

Primer

Primer getCommentsForUser

Copy

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

addDomainConfig

Parametri

Ime	Tip	Potrebno	Opis
tenantId	string	Da
addDomainConfigParams	AddDomainConfigParams	Da

Odgovor

Vrne: AddDomainConfigResponse

Primer

addDomainConfig Primer

Copy

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

deleteDomainConfig

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
domain	string	Da

Odgovor

Vrne: DeleteDomainConfigResponse

Primer

deleteDomainConfig Primer

Copy

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

getDomainConfig

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
domain	string	Da

Odgovor

Vrne: GetDomainConfigResponse

Primer

Primer getDomainConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domain = U("myblog.example.com");
api->getDomainConfig(tenantId, domain)
    .then([](std::shared_ptr<GetDomainConfigResponse> response) {
        if (!response) return;
        boost::optional<bool> moderationEnabled = response->moderationEnabled;
        boost::optional<std::string> theme = response->theme;
        if (moderationEnabled && *moderationEnabled) {
            // obravnava omogočeno moderiranje
        }
        if (theme) {
            // uporabi vrednost teme
        }
    })
    .wait();

getDomainConfigs

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes

Odgovor

Vrne: GetDomainConfigsResponse

Primer

Primer getDomainConfigs

Copy

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

patchDomainConfig

Parametri

Ime	Tip	Obvezno
tenantId	string	Yes
domainToUpdate	string	Yes
patchDomainConfigParams	PatchDomainConfigParams	Yes

Odgovor

Vrne: PatchDomainConfigResponse

Primer

patchDomainConfig Primer

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto domainToUpdate = utility::conversions::to_string_t("example.com");
PatchDomainConfigParams patchDomainConfigParams;
patchDomainConfigParams.enableComments = boost::optional<bool>(true);
patchDomainConfigParams.moderationLevel = boost::optional<int>(2);
patchDomainConfigParams.customHeader = boost::optional<utility::string_t>(utility::conversions::to_string_t("X-Custom-Header"));
api->patchDomainConfig(tenantId, domainToUpdate, patchDomainConfigParams)
    .then([](std::shared_ptr<PatchDomainConfigResponse> resp) {
        // obdelava uspeha
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* obdelava napake */ }
    });

putDomainConfig

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
domainToUpdate	string	Da
updateDomainConfigParams	UpdateDomainConfigParams	Da

Odgovor

Vrne: PutDomainConfigResponse

Primer

putDomainConfig Primer

Copy

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

createEmailTemplate

Parametri

Ime	Tip	Potrebno	Opis
tenantId	string	Yes
createEmailTemplateBody	CreateEmailTemplateBody	Yes

Odgovor

Returns: CreateEmailTemplateResponse

Primer

Primer createEmailTemplate

Copy

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

deleteEmailTemplate

Parametri

Ime	Tip	Zahtevano	Opis
tenantId	string	Yes
id	string	Yes

Odgovor

Vrne: APIEmptyResponse

Primer

deleteEmailTemplate Primer

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto templateId = utility::conversions::to_string_t("welcome-email-template");
boost::optional<utility::string_t> optTenantId = tenantId;
boost::optional<utility::string_t> optTemplateId = templateId;
api->deleteEmailTemplate(optTenantId.value(), optTemplateId.value())
    .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> t) {
        try { t.get(); }
        catch (const std::exception&) {}
    });

deleteEmailTemplateRenderError

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Da
id	string	Da
errorId	string	Da

Odgovor

Vrne: APIEmptyResponse

Primer

deleteEmailTemplateRenderError Primer

Copy

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

getEmailTemplate

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Yes
id	string	Yes

Odgovor

Vrne: GetEmailTemplateResponse

Primer

Primer getEmailTemplate

Copy

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

getEmailTemplateDefinitions

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da

Odgovor

Vrne: GetEmailTemplateDefinitionsResponse

Primer

Primer getEmailTemplateDefinitions

Copy

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

getEmailTemplateRenderErrors

Parameters

Ime	Vrsta	Obvezno
tenantId	string	Da
id	string	Da
skip	double	Ne

Response

Vrne: GetEmailTemplateRenderErrorsResponse

Example

getEmailTemplateRenderErrors Primer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("email-template-789");
boost::optional<double> skip = 20.0;
api->getEmailTemplateRenderErrors(tenantId, id, skip)
    .then([](pplx::task<std::shared_ptr<GetEmailTemplateRenderErrorsResponse>> task) {
        try {
            auto response = task.get();
            // Uporabite odziv po potrebi
        } catch (const std::exception& ex) {
            // Obdelajte napako
        }
    });

getEmailTemplates

Parametri

Ime	Tip	Zahtevano	Opis
tenantId	string	Da
skip	double	Ne

Odziv

Vrne: GetEmailTemplatesResponse

Primer

Primer getEmailTemplates

Copy

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

renderEmailTemplate

Parameters

Ime	Vrsta	Obvezno
tenantId	string	Da
renderEmailTemplateBody	RenderEmailTemplateBody	Da
locale	string	Ne

Odgovor

Vrne: RenderEmailTemplateResponse

Primer

renderEmailTemplate Primer

Copy

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

updateEmailTemplate

Parametri

Ime	Tip	Obvezno
tenantId	string	Yes
id	string	Yes
updateEmailTemplateBody	UpdateEmailTemplateBody	Yes

Odgovor

Vrne: APIEmptyResponse

Primer

Primer updateEmailTemplate

Copy

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

getEventLog

req tenantId urlId userIdWS

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
urlId	string	Yes
userIdWS	string	Yes
startTime	int64_t	Yes
endTime	int64_t	No

Odgovor

Vrne: GetEventLogResponse

Primer

getEventLog Primer

Copy

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

getGlobalEventLog

req tenantId urlId userIdWS

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Da
urlId	string	Da
userIdWS	string	Da
startTime	int64_t	Da
endTime	int64_t	Ne

Odziv

Vrne: GetEventLogResponse

Primer

Primer getGlobalEventLog

Copy

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

createFeedPost

Parameters

Ime	Tip	Obvezno
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
options	const CreateFeedPostOptions&	Yes

Response

Vrne: CreateFeedPostsResponse

Example

createFeedPost Primer

Copy

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

createFeedPostPublic

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Da
createFeedPostParams	CreateFeedPostParams	Da
options	const CreateFeedPostPublicOptions&	Da

Odziv

Vrne: CreateFeedPostResponse

Primer

createFeedPostPublic Primer

Copy

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

deleteFeedPostPublic

Parametri

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

Odgovor

Vrne: DeleteFeedPostPublicResponse

Primer

deleteFeedPostPublic Primer

Copy

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

getFeedPosts

req tenantId afterId

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
options	const GetFeedPostsOptions&	Da

Odgovor

Vrne: GetFeedPostsResponse

Primer

Primer getFeedPosts

Copy

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

getFeedPostsPublic

req tenantId afterId

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
options	const GetFeedPostsPublicOptions&	Da

Odgovor

Vrne: PublicFeedPostsResponse

Primer

Primer getFeedPostsPublic

Copy

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

getFeedPostsStats

Parametri

Ime	Tip	Zahtevano
tenantId	string	Yes
postIds	vector<string	Yes
sso	string	No

Odziv

Vračajo: FeedPostsStatsResponse

Primer

getFeedPostsStats Primer

Copy

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

getUserReactsPublic

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
options	const GetUserReactsPublicOptions&	Da

Odgovor

Vrne: UserReactsResponse

Primer

getUserReactsPublic Primer

Copy

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

reactFeedPostPublic

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
postId	string	Da
reactBodyParams	ReactBodyParams	Da
options	const ReactFeedPostPublicOptions&	Da

Odgovor

Vrne: ReactFeedPostResponse

Primer

reactFeedPostPublic Primer

Copy

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

updateFeedPost

Parametri

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

Odgovor

Vrne: APIEmptyResponse

Primer

Primer updateFeedPost

Copy

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

updateFeedPostPublic

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
postId	string	Yes
updateFeedPostParams	UpdateFeedPostParams	Yes
options	const UpdateFeedPostPublicOptions&	Yes

Odgovor

Vrne: CreateFeedPostResponse

Primer

Primer updateFeedPostPublic

Copy

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

flagCommentPublic

Parametri

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

Odgovor

Vrne: APIEmptyResponse

Primer

flagCommentPublic Primer

Copy

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

getGifLarge

Parametri

Name	Type	Required	Description
tenantId	string	Da
largeInternalURLSanitized	string	Da

Odgovor

Vrne: GifGetLargeResponse

Primer

getGifLarge Primer

Copy

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

getGifsSearch

Parametri

Ime	Tip	Obvezno
tenantId	string	Yes
search	string	Yes
options	const GetGifsSearchOptions&	Yes

Odgovor

Vrne: GetGifsSearchResponse

Primer

getGifsSearch Primer

Copy

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

getGifsTrending

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
options	const GetGifsTrendingOptions&	Da

Odgovor

Vrne: GetGifsTrendingResponse

Primer

Primer getGifsTrending

Copy

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

addHashTag

Parameters

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
createHashTagBody	CreateHashTagBody	Yes

Odziv

Vrne: CreateHashTagResponse

Primer

Primer addHashTag

Copy

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

addHashTagsBulk

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Yes

Odgovor

Vrne: BulkCreateHashTagsResponse

Primer

addHashTagsBulk Primer

Copy

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

deleteHashTag

Parametri

Ime	Tip	Zahtevano
tenantId	string	Yes
tag	string	Yes
deleteHashTagRequestBody	DeleteHashTagRequestBody	Yes

Odgovor

Vrne: APIEmptyResponse

Primer

deleteHashTag Primer

Copy

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

getHashTags

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
page	double	Ne

Odgovor

Vrne: GetHashTagsResponse

Primer

Primer getHashTags

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
boost::optional<double> page = 2.0;
api->getHashTags(tenantId, page).then([](pplx::task<std::shared_ptr<GetHashTagsResponse>> task) {
    try {
        auto resultPtr = task.get();
        auto response = std::make_shared<GetHashTagsResponse>(*resultPtr);
        // uporabi odgovor
    } catch (const std::exception&) {
        // obravnavaj napako
    }
});

patchHashTag

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
tag	string	Yes
updateHashTagBody	UpdateHashTagBody	Yes

Odgovor

Vrne: UpdateHashTagResponse

Primer

patchHashTag Primer

Copy

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

deleteModerationVote

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Da
commentId	string	Da
voteId	string	Da
options	const DeleteModerationVoteOptions&	Da

Odgovor

Vrne: VoteDeleteResponse

Primer

deleteModerationVote Primer

Copy

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

getApiComments

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
options	const GetApiCommentsOptions&	Da

Odgovor

Vrne: ModerationAPIGetCommentsResponse

Primer

getApiComments Primer

Copy

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

getApiExportStatus

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
options	const GetApiExportStatusOptions&	Da

Odgovor

Vrne: ModerationExportStatusResponse

Primer

Primer getApiExportStatus

Copy

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

getApiIds

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
options	const GetApiIdsOptions&	Yes

Odgovor

Vrne: ModerationAPIGetCommentIdsResponse

Primer

Primer getApiIds

Copy

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

getBanUsersFromComment

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
commentId	string	Da
sso	string	Ne

Odziv

Vrne: GetBannedUsersFromCommentResponse

Primer

getBanUsersFromComment Primer

Copy

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

getCommentBanStatus

Parameters

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

Response

Returns: GetCommentBanStatusResponse

Primer

Primer getCommentBanStatus

Copy

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

getCommentChildren

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Da
commentId	string	Da
sso	string	Ne

Odziv

Vrne: ModerationAPIChildCommentsResponse

Primer

Primer getCommentChildren

Copy

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

getCount

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
options	const GetCountOptions&	Yes

Odgovor

Vrne: ModerationAPICountCommentsResponse

Primer

Primer getCount

Copy

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

getCounts

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
sso	string	Ne

Odgovor

Vrne: GetBannedUsersCountResponse

Primer

getCounts Primer

Copy

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

getLogs

Parametri

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

Odgovor

Vrnitev: ModerationAPIGetLogsResponse

Primer

Primer getLogs

Copy

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

getManualBadges

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
sso	string	Ne

Odgovor

Vrne: GetTenantManualBadgesResponse

Primer

getManualBadges Primer

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> sso = boost::make_optional(U("user@example.com"));
api->getManualBadges(tenantId, sso)
    .then([](pplx::task<std::shared_ptr<GetTenantManualBadgesResponse>> t) {
        try {
            auto response = t.get();
            // obdelaj odgovor, npr., response->badgeList
        } catch (const std::exception& ex) {
            // obravnavaj napako
        }
    });

getManualBadgesForUser

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
options	const GetManualBadgesForUserOptions&	Da

Odgovor

Vrne: GetUserManualBadgesResponse

Primer

getManualBadgesForUser Primer

Copy

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

getModerationComment

Parametri

Ime	Tip	Obvezno
tenantId	string	Yes
commentId	string	Yes
options	const GetModerationCommentOptions&	Yes

Odgovor

Vrne: ModerationAPICommentResponse

Primer

Primer getModerationComment

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-456");
GetModerationCommentOptions options;
options.includeDeleted = boost::optional<bool>(true);
options.locale = boost::optional<utility::string_t>(utility::conversions::to_string_t("en-US"));
api->getModerationComment(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<ModerationAPICommentResponse>> task) {
        try {
            auto response = task.get();
            // Obdelajte odgovor po potrebi
        } catch (const std::exception& ex) {
            // Obvladujte napako
        }
    });

getModerationCommentText

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
commentId	string	Da
sso	string	Ne

Odgovor

Vrne: GetCommentTextResponse

Primer

getModerationCommentText Primer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654");
boost::optional<utility::string_t> sso = U("sso-token-abc");
api->getModerationCommentText(tenantId, commentId, sSO)
    .then([](pplx::task<std::shared_ptr<GetCommentTextResponse>> t) {
        try {
            auto resp = t.get();
            auto text = std::make_shared<std::string>(resp->commentText);
        } catch (const std::exception&) {
        }
    });

getPreBanSummary

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
commentId	string	Yes
options	const GetPreBanSummaryOptions&	Yes

Odgovor

Vrne: PreBanSummary

Primer

Primer getPreBanSummary

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("cmt-456789");
GetPreBanSummaryOptions options;
options.locale = boost::optional<utility::string_t>{utility::conversions::to_string_t("en-US")};
api->getPreBanSummary(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<PreBanSummary>> t) {
        try {
            auto summary = t.get();
            // process summary
        } catch (const std::exception&) {
            // handle error
        }
    });

getSearchCommentsSummary

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
options	const GetSearchCommentsSummaryOptions&	Yes

Odgovor

Vrne: ModerationCommentSearchResponse

Primer

getSearchCommentsSummary Primer

Copy

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

getSearchPages

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
options	const GetSearchPagesOptions&	Da

Odgovor

Vrne: ModerationPageSearchResponse

Primer

Primer getSearchPages

Copy

GetSearchPagesOptions options;
options.pageNumber = boost::optional<int>(1);
options.pageSize = boost::optional<int>(50);
options.searchTerm = boost::optional<utility::string_t>(U("spam"));
api->getSearchPages(U("my-tenant-123"), options)
    .then([](pplx::task<std::shared_ptr<ModerationPageSearchResponse>> task) {
        try {
            auto response = task.get();
            // uporabi odgovor
        } catch (const std::exception& e) {
            // obravnavaj napako
        }
    });

getSearchSites

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Yes
options	const GetSearchSitesOptions&	Yes

Odziv

Vrne: ModerationSiteSearchResponse

Primer

Primer getSearchSites

Copy

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

getSearchSuggest

Parametri

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

Odgovor

Vrne: ModerationSuggestResponse

Primer

Primer getSearchSuggest

Copy

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

getSearchUsers

Parametri

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

Odziv

Vrne: ModerationUserSearchResponse

Primer

Primer getSearchUsers

Copy

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

getTrustFactor

Parametri

Ime	Tip	Zahtevano	Opis
tenantId	string	Da
options	const GetTrustFactorOptions&	Da

Odgovor

Vrne: GetUserTrustFactorResponse

Primer

Primer getTrustFactor

Copy

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

getUserBanPreference

Parametri

Name	Type	Required	Description
tenantId	string	Da
sso	string	Ne

Odziv

Vrne: APIModerateGetUserBanPreferencesResponse

Primer

Primer getUserBanPreference

Copy

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

getUserInternalProfile

Parametri

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

Odgovor

Vrne: GetUserInternalProfileResponse

Primer

Primer getUserInternalProfile

Copy

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

postAdjustCommentVotes

Parametri

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

Odgovor

Vrne: AdjustVotesResponse

Primer

postAdjustCommentVotes Primer

Copy

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

postApiExport

Parametri

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

Odgovor

Vrne: ModerationExportResponse

Primer

postApiExport Primer

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
PostApiExportOptions options;
options.format = utility::string_t(U("json"));
options.email = utility::string_t(U("reports@example.com"));
options.startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-01T00:00:00Z")));
options.endDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-31T23:59:59Z")));
api->postApiExport(tenantId, options)
    .then([](std::shared_ptr<ModerationExportResponse> response) {
        if (response) {
            // obravnava uspešen izvozni odziv
        }
    })
    .wait();

postBanUserFromComment

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
commentId	string	Da
options	const PostBanUserFromCommentOptions&	Da

Vrne

Vrne: BanUserFromCommentResult

Primer

postBanUserFromComment Primer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("comment-456789");
PostBanUserFromCommentOptions options;
options.reason = boost::optional<utility::string_t>(U("spam"));
options.durationDays = boost::optional<int>(30);
api->postBanUserFromComment(tenantId, commentId, options)
    .then([](std::shared_ptr<BanUserFromCommentResult> result) {
        // obdelava rezultata
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* obdelava napake */ }
    });

postBanUserUndo

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
banUserUndoParams	BanUserUndoParams	Da
sso	string	Ne

Odgovor

Vrne: APIEmptyResponse

Primer

postBanUserUndo Primer

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
BanUserUndoParams banParams;
banParams.userId = utility::string_t(U("user-567"));
banParams.reason = utility::string_t(U("reinstated"));
boost::optional<utility::string_t> sso = utility::string_t(U("sso-token-abc"));
api->postBanUserUndo(tenantId, banParams, sso).then([](std::shared_ptr<APIEmptyResponse> resp){
    // obravnava uspeha
});

postBulkPreBanSummary

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Da
bulkPreBanParams	BulkPreBanParams	Da
options	const PostBulkPreBanSummaryOptions&	Da

Odgovor

Vrne: BulkPreBanSummary

Primer

postBulkPreBanSummary Primer

Copy

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

postCommentsByIds

Parameters

Ime	Tip	Obvezno
tenantId	string	Yes
commentsByIdsParams	CommentsByIdsParams	Yes
sso	string	No

Response

Vrne: ModerationAPIChildCommentsResponse

Example

postCommentsByIds Primer

Copy

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

postFlagComment

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
commentId	string	Yes
options	const PostFlagCommentOptions&	Yes

Odgovor

Returns: APIEmptyResponse

Primer

postFlagComment Primer

Copy

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

postRemoveComment

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
commentId	string	Da
options	const PostRemoveCommentOptions&	Da

Odgovor

Vrne: PostRemoveCommentApiResponse

Primer

postRemoveComment Primer

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto commentId = utility::string_t(U("cmt-456789"));
PostRemoveCommentOptions options;
options.permanent = boost::optional<bool>(true);
api->postRemoveComment(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<PostRemoveCommentApiResponse>> task) {
        try {
            auto response = task.get();
            // Process response
        } catch (const std::exception& ex) {
            // Handle error
        }
    });

postRestoreDeletedComment

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Da
commentId	string	Da
options	const PostRestoreDeletedCommentOptions&	Da

Odziv

Vrne: APIEmptyResponse

Primer

postRestoreDeletedComment Primer

Copy

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

postSetCommentApprovalStatus

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentApprovalStatusOptions&	Yes

Odgovor

Vrne: SetCommentApprovedResponse

Primer

postSetCommentApprovalStatus Primer

Copy

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

postSetCommentReviewStatus

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
commentId	string	Da
options	const PostSetCommentReviewStatusOptions&	Da

Odgovor

Vrne: APIEmptyResponse

Primer

postSetCommentReviewStatus Primer

Copy

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

postSetCommentSpamStatus

Parametri

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

Odgovor

Vrne: APIEmptyResponse

Primer

postSetCommentSpamStatus Primer

Copy

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

postSetCommentText

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
commentId	string	Yes
setCommentTextParams	SetCommentTextParams	Yes
options	const PostSetCommentTextOptions&	Yes

Odziv

Vrne: SetCommentTextResponse

Primer

postSetCommentText Primer

Copy

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

postUnFlagComment

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
commentId	string	Da
options	const PostUnFlagCommentOptions&	Da

Odgovor

Vrne: APIEmptyResponse

Primer

postUnFlagComment Primer

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
PostUnFlagCommentOptions opts;
opts.notifyUser = boost::optional<bool>(true);
api->postUnFlagComment(tenantId, commentId, opts)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // obdelavo je mogoče izvesti tukaj
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

postVote

Parametri

Ime	Tip	Obvezno
tenantId	string	Yes
commentId	string	Yes
options	const PostVoteOptions&	Yes

Odgovor

Vrne: VoteResponse

Primer

postVote Primer

Copy

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

putAwardBadge

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
badgeId	string	Yes
options	const PutAwardBadgeOptions&	Yes

Odziv

Vrne: AwardUserBadgeResponse

Primer

putAwardBadge Primer

Copy

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

putCloseThread

Parametri

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

Odgovor

Vrne: APIEmptyResponse

Primer

putCloseThread Primer

Copy

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

putRemoveBadge

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
badgeId	string	Da
options	const PutRemoveBadgeOptions&	Da

Odgovor

Vrne: RemoveUserBadgeResponse

Primer

putRemoveBadge Primer

Copy

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

putReopenThread

Parametri

Ime	Tip	Obvezno
tenantId	string	Yes
urlId	string	Yes
sso	string	No

Odgovor

Vrne: APIEmptyResponse

Primer

putReopenThread Primer

Copy

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

setTrustFactor

Parameters

Ime	Tip	Obvezno	Opis
tenantId	string	Da
options	const SetTrustFactorOptions&	Da

Response

Vrne: SetUserTrustFactorResponse

Primer

setTrustFactor Primer

Copy

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

createModerator

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
createModeratorBody	CreateModeratorBody	Da

Odgovor

Vrne: CreateModeratorResponse

Primer

Primer createModerator

Copy

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

deleteModerator

Parametri

Ime	Tip	Obvezno
tenantId	string	Yes
id	string	Yes
sendEmail	string	No

Odgovor

Vrne: APIEmptyResponse

Primer

deleteModerator Primer

Copy

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

getModerator

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
id	string	Da

Odziv

Vrne: GetModeratorResponse

Primer

getModerator Primer

Copy

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

getModerators

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Yes
skip	double	No

Odgovor

Vrne: GetModeratorsResponse

Primer

getModerators Primer

Copy

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

sendInvite

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
id	string	Da
fromName	string	Da

Odgovor

Vrne: APIEmptyResponse

Primer

sendInvite Primer

Copy

boost::optional<utility::string_t> cc = utility::conversions::to_string_t("cc@example.com");
api->sendInvite(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("invitee@example.com"),
    utility::conversions::to_string_t("John Doe")
).then([](std::shared_ptr<APIEmptyResponse> resp) {
    // obdelaj uspešno povabilo
});

updateModerator

Parametri

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

Odgovor

Vrne: APIEmptyResponse

Primer

updateModerator Primer

Copy

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

deleteNotificationCount

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vrne: APIEmptyResponse

Primer

Primer deleteNotificationCount

Copy

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

getCachedNotificationCount

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
id	string	Da

Odziv

Vrne: GetCachedNotificationCountResponse

Primer

getCachedNotificationCount Primer

Copy

auto tenantId = boost::optional<utility::string_t>(utility::conversions::to_string_t("my-tenant-123"));
auto userId = boost::optional<utility::string_t>(utility::conversions::to_string_t("user-456"));
api->getCachedNotificationCount(tenantId.value(), userId.value())
    .then([](pplx::task<std::shared_ptr<GetCachedNotificationCountResponse>> task) {
        try {
            auto response = task.get();
            // obdelaj odgovor
        } catch (const std::exception&) {
            // obravnava napake
        }
    });

getNotificationCount

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
options	const GetNotificationCountOptions&	Yes

Odgovor

Vrne: GetNotificationCountResponse

Primer

getNotificationCount Primer

Copy

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

getNotifications

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
options	const GetNotificationsOptions&	Da

Odgovor

Vrne: GetNotificationsResponse

Primer

Primer getNotifications

Copy

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

updateNotification

Parametri

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

Odziv

Vrne: APIEmptyResponse

Primer

Primer updateNotification

Copy

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

createV1PageReact

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
urlId	string	Da
title	string	Ne

Odgovor

Vrne: CreateV1PageReact

Primer

Primer createV1PageReact

Copy

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

createV2PageReact

Parametri

Ime	Tip	Obvezno
tenantId	string	Yes
urlId	string	Yes
id	string	Yes
title	string	No

Odgovor

Vrne: CreateV1PageReact

Primer

createV2PageReact Primer

Copy

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

deleteV1PageReact

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
urlId	string	Da

Odgovor

Vrne: CreateV1PageReact

Primer

deleteV1PageReact Primer

Copy

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

deleteV2PageReact

Parametri

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
id	string	Yes

Odgovor

Vrne: CreateV1PageReact

Primer

deleteV2PageReact Primer

Copy

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

getV1PageLikes

Parametri

Ime	Tip	Potrebno	Opis
tenantId	string	Yes
urlId	string	Yes

Odgovor

Vrne: GetV1PageLikes

Primer

getV1PageLikes Primer

Copy

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

getV2PageReacts

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
urlId	string	Yes

Odgovor

Vrne: GetV2PageReacts

Primer

Primer getV2PageReacts

Copy

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

getV2PageReactUsers

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
urlId	string	Yes
id	string	Yes

Odziv

Vrne: GetV2PageReactUsersResponse

Primer

Primer getV2PageReactUsers

Copy

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

addPage

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
createAPIPageData	CreateAPIPageData	Yes

Odgovor

Returns: AddPageAPIResponse

Primer

addPage Primer

Copy

auto createData = CreateAPIPageData{};
createData.title = utility::string_t(U("Welcome Page"));
createData.url = utility::string_t(U("https://example.com/welcome"));
createData.description = boost::optional<utility::string_t>(utility::string_t(U("Landing page for new users")));
api->addPage(utility::string_t(U("my-tenant-123")), createData)
    .then([](std::shared_ptr<AddPageAPIResponse> response) {
        if (response && response->success) {
            // obravnava uspešno dodajanje
        } else {
            // obravnava napako
        }
    });

deletePage

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Returns: DeletePageAPIResponse

Primer

deletePage Primer

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto pageId   = utility::conversions::to_string_t("page-456");
api->deletePage(tenantId, pageId)
   .then([](pplx::task<std::shared_ptr<DeletePageAPIResponse>> t) {
       try {
           auto response = t.get();
           // obdelaj odgovor po potrebi
       } catch (const std::exception& ex) {
           // obravnavaj napako
       }
   });

getOfflineUsers

Prejšnji komentatorji na strani, KI NI TRENUTNO online. Razvrščeni po displayName.
Uporabite to po izčrpanju /users/online za izris odseka "Members".
Cursor paginiranje po commenterName: strežnik hodi po delnem {tenantId, urlId, commenterName} indeksu od afterName naprej preko $gt, brez stroška $skip.

Parameters

Ime	Tip	Obvezno
tenantId	string	Yes
urlId	string	Yes
options	const GetOfflineUsersOptions&	Yes

Odgovor

Vrne: PageUsersOfflineResponse

Primer

Primer getOfflineUsers

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("page-456");
GetOfflineUsersOptions options;
options.limit = boost::optional<int>(50);
options.includeDetails = boost::optional<bool>(true);
api->getOfflineUsers(tenantId, urlId, options)
    .then([](pplx::task<std::shared_ptr<PageUsersOfflineResponse>> t) {
        try {
            auto response = t.get();
        } catch (const std::exception&) {
        }
    });

getOnlineUsers

Currently-online viewers of a page: people whose websocket session is subscribed to the page right now. Trenutno prisotni gledalci strani: ljudje, katerih sejo WebSocket je v tem trenutku naročena na stran.

Returns anonCount + totalCount (room-wide subscribers, including anon viewers we don't enumerate). Vrne anonCount + totalCount (naročniki po celotni sobi, vključno z anonimnimi gledalci, ki jih ne naštejemo).

Parameters

Ime	Vrsta	Obvezno
tenantId	string	Da
urlId	string	Da
options	const GetOnlineUsersOptions&	Da

Response

Vrne: PageUsersOnlineResponse

Example

Primer getOnlineUsers

Copy

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

getPageByURLId

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
urlId	string	Yes

Odgovor

Vrne: GetPageByURLIdAPIResponse

Primer

getPageByURLId Primer

Copy

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

getPages

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da

Odgovor

Vrne: GetPagesAPIResponse

Primer

Primer getPages

Copy

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

getPagesPublic

Naštej strani za najemnika. Uporablja ga namizni odjemalec FChat za napolnitev seznama sob.
Zahteva, da je enableFChat nastavljen na true v razrešenih prilagojenih nastavitvah za vsako stran.
Strani, ki zahtevajo SSO, so filtrirane glede na skupinski dostop zahtevanega uporabnika.

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Yes
options	const GetPagesPublicOptions&	Yes

Odgovor

Vrne: GetPublicPagesResponse

Primer

Primer getPagesPublic

Copy

utility::string_t tenantId = U("my-tenant-123");
GetPagesPublicOptions options;
options.limit = boost::optional<int>(50);
options.cursor = boost::optional<utility::string_t>(U("cursor-token"));
api->getPagesPublic(tenantId, options).then([](pplx::task<std::shared_ptr<GetPublicPagesResponse>> task){
    try{
        auto response = task.get();
        // obdelaj odgovor po potrebi
    }catch(const std::exception&){
        // obravnavaj napako po potrebi
    }
});

getUsersInfo

Masovni podatki o uporabniku za najemnika. Glede na userIds vrne prikazne informacije iz User / SSOUser.
Uporablja se v pripomočku za komentarje za obogatitev uporabnikov, ki so se pravkar pojavili preko dogodka prisotnosti.
Brez konteksta strani: zasebnost je dosledno uveljavljena (zasebni profili so maskirani).

Parameters

Ime	Tip	Obvezno	Opis
tenantId	string	Da
ids	string	Da

Response

Returns: PageUsersInfoResponse

Example

Primer getUsersInfo

Copy

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

patchPage

Parametri

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

Odziv

Vrne: PatchPageAPIResponse

Primer

patchPage Primer

Copy

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

deletePendingWebhookEvent

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
id	string	Da

Odziv

Vrne: APIEmptyResponse

Primer

deletePendingWebhookEvent Primer

Copy

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

getPendingWebhookEventCount

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
options	const GetPendingWebhookEventCountOptions&	Da

Odgovor

Vrne: GetPendingWebhookEventCountResponse

Primer

getPendingWebhookEventCount Primer

Copy

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

getPendingWebhookEvents

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Yes
options	const GetPendingWebhookEventsOptions&	Yes

Odgovor

Vrne: GetPendingWebhookEventsResponse

Primer

getPendingWebhookEvents Primer

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
GetPendingWebhookEventsOptions opts;
opts.pageSize = boost::optional<int>(100);
opts.startAfter = boost::optional<utility::string_t>(U("event-abc-456"));
api->getPendingWebhookEvents(tenantId, opts)
    .then([](pplx::task<std::shared_ptr<GetPendingWebhookEventsResponse>> task) {
        try {
            auto resp = task.get();
            auto copy = std::make_shared<GetPendingWebhookEventsResponse>(*resp);
        } catch (const std::exception&) {}
    });

createQuestionConfig

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
createQuestionConfigBody	CreateQuestionConfigBody	Da

Odgovor

Vrne: CreateQuestionConfigResponse

Primer

createQuestionConfig Primer

Copy

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

deleteQuestionConfig

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
id	string	Yes

Odgovor

Returns: APIEmptyResponse

Primer

Primer deleteQuestionConfig

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto configId = utility::conversions::to_string_t("question-config-456");
api->deleteQuestionConfig(tenantId, configId)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // handle successful deletion
    })
    .then([](pplx::task<void> t) {
        try {
            t.get();
        } catch (const std::exception&) {
            // handle error
        }
    });

getQuestionConfig

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vrne: GetQuestionConfigResponse

Primer

Primer getQuestionConfig

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto questionId = utility::conversions::to_string_t("question-456");
api->getQuestionConfig(tenantId, questionId)
    .then([](pplx::task<std::shared_ptr<GetQuestionConfigResponse>> task) {
        try {
            auto response = task.get();
            // Uporabite odgovor po potrebi
        } catch (const std::exception&) {
            // Obdelajte napako
        }
    });

getQuestionConfigs

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
skip	double	Ne

Odgovor

Vrne: GetQuestionConfigsResponse

Primer

getQuestionConfigs Primer

Copy

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

updateQuestionConfig

Parametri

Ime	Tip	Obvezno
tenantId	string	Yes
id	string	Yes
updateQuestionConfigBody	UpdateQuestionConfigBody	Yes

Odgovor

Vrne: APIEmptyResponse

Primer

updateQuestionConfig Primer

Copy

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

createQuestionResult

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
createQuestionResultBody	CreateQuestionResultBody	Yes

Odgovor

Vrne: CreateQuestionResultResponse

Primer

Primer createQuestionResult

Copy

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

deleteQuestionResult

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
id	string	Da

Odziv

Vrne: APIEmptyResponse

Primer

Primer deleteQuestionResult

Copy

boost::optional<utility::string_t> optTenant = utility::conversions::to_string_t( "my-tenant-123" );
utility::string_t questionId = utility::conversions::to_string_t( "question-456" );
if ( optTenant )
{
    api->deleteQuestionResult( *optTenant, questionId )
        .then( []( pplx::task<std::shared_ptr<APIEmptyResponse>> t )
        {
            try
            {
                auto resp = t.get();
                // obravnava uspeha
            }
            catch ( const std::exception& e )
            {
                // obravnava napake
            }
        } );
}

getQuestionResult

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vrne: GetQuestionResultResponse

Primer

getQuestionResult Primer

Copy

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

getQuestionResults

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
options	const GetQuestionResultsOptions&	Da

Odgovor

Vrne: GetQuestionResultsResponse

Primer

Primer getQuestionResults

Copy

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

updateQuestionResult

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
id	string	Yes
updateQuestionResultBody	UpdateQuestionResultBody	Yes

Odgovor

Vrne: APIEmptyResponse

Primer

Primer updateQuestionResult

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto questionId = utility::string_t(U("question-456"));
UpdateQuestionResultBody body;
body.result = U("approved");
body.note = boost::optional<utility::string_t>(U("Reviewed by admin"));
api->updateQuestionResult(tenantId, questionId, body)
    .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> t) {
        try {
            auto respPtr = std::make_shared<APIEmptyResponse>(*t.get());
        } catch (const std::exception&) {
        }
    });

aggregateQuestionResults

Params

Ime	Vrsta	Obvezno	Opis
tenantId	string	Yes
options	const AggregateQuestionResultsOptions&	Yes

Odgovor

Vrne: AggregateQuestionResultsResponse

Primer

aggregateQuestionResults Primer

Copy

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

bulkAggregateQuestionResults

Parametri

Ime	Tip	Obvezno
tenantId	string	Yes
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Yes
forceRecalculate	bool	No

Odgovor

Vrne: BulkAggregateQuestionResultsResponse

Primer

bulkAggregateQuestionResults Primer

Copy

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

combineCommentsWithQuestionResults

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
options	const CombineCommentsWithQuestionResultsOptions&	Da

Odgovor

Vrne: CombineQuestionResultsWithCommentsResponse

Primer

combineCommentsWithQuestionResults Primer

Copy

utility::string_t tenantId = utility::string_t("my-tenant-123");
CombineCommentsWithQuestionResultsOptions options;
options.questionId = utility::string_t("question-789");
options.maxComments = boost::optional<int>(50);
api->combineCommentsWithQuestionResults(tenantId, options).then(
    [](pplx::task<std::shared_ptr<CombineQuestionResultsWithCommentsResponse>> task){
        try{
            auto respPtr = task.get();
            auto combined = std::make_shared<CombineQuestionResultsWithCommentsResponse>(*respPtr);
            // Uporabite combined po potrebi
        }catch(const std::exception&){
        }
    });

addSSOUser

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
createAPISSOUserData	CreateAPISSOUserData	Da

Odgovor

Vrne: AddSSOUserAPIResponse

Primer

addSSOUser Primer

Copy

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

deleteSSOUser

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
id	string	Yes
options	const DeleteSSOUserOptions&	Yes

Odgovor

Vrne: DeleteSSOUserAPIResponse

Primer

deleteSSOUser Primer

Copy

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

getSSOUserByEmail

Parametri

Name	Type	Required	Description
tenantId	string	Yes
email	string	Yes

Odgovor

Returns: GetSSOUserByEmailAPIResponse

Primer

getSSOUserByEmail Primer

Copy

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

getSSOUserById

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vrne: GetSSOUserByIdAPIResponse

Primer

Primer getSSOUserById

Copy

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

getSSOUsers

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
skip	int32_t	Ne

Odgovor

Vrne: GetSSOUsersResponse

Primer

Primer getSSOUsers

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<int32_t> skip = 25;
api->getSSOUsers(tenantId, skip).then([](pplx::task<std::shared_ptr<GetSSOUsersResponse>> t) {
    try {
        auto response = t.get();
    } catch (const std::exception&) {
    }
});

patchSSOUser

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
id	string	Yes
updateAPISSOUserData	UpdateAPISSOUserData	Yes
updateComments	bool	No

Odgovor

Vrne: PatchSSOUserAPIResponse

Primer

patchSSOUser Primer

Copy

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

putSSOUser

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
id	string	Da
updateAPISSOUserData	UpdateAPISSOUserData	Da
updateComments	bool	Ne

Odziv

Vrne: PutSSOUserAPIResponse

Primer

putSSOUser Primer

Copy

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

createSubscription

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Da

Odgovor

Vrne: CreateSubscriptionAPIResponse

Primer

createSubscription Primer

Copy

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

deleteSubscription

Parametri

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

Odgovor

Vrne: DeleteSubscriptionAPIResponse

Primer

Primer deleteSubscription

Copy

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

getSubscriptions

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
userId	string	Ne

Odgovor

Vrne: GetSubscriptionsAPIResponse

Primer

Primer getSubscriptions

Copy

auto tenant = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> user = utility::conversions::to_string_t("user@example.com");
api->getSubscriptions(tenant, user).then(
    [](pplx::task<std::shared_ptr<GetSubscriptionsAPIResponse>> t) {
        try {
            auto response = t.get();
            // obdelaj odgovor
        } catch (const std::exception& e) {
            // obravnavaj napako
        }
    }
);

updateSubscription

Parameters

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

Response

Vrne: UpdateSubscriptionAPIResponse

Primer

updateSubscription Primer

Copy

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

getTenantDailyUsages

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
options	const GetTenantDailyUsagesOptions&	Da

Odgovor

Vrne: GetTenantDailyUsagesResponse

Primer

getTenantDailyUsages Primer

Copy

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

createTenantPackage

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
createTenantPackageBody	CreateTenantPackageBody	Da

Odgovor

Vrne: CreateTenantPackageResponse

Primer

createTenantPackage Primer

Copy

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

deleteTenantPackage

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vrne: APIEmptyResponse

Primer

Primer deleteTenantPackage

Copy

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

getTenantPackage

Parameters

Ime	Tip	Obvezno	Opis
tenantId	string	Da
id	string	Da

Response

Vrne: GetTenantPackageResponse

Example

Primer getTenantPackage

Copy

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

getTenantPackages

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
skip	double	Ne

Odgovor

Vrne: GetTenantPackagesResponse

Primer

Primer getTenantPackages

Copy

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

replaceTenantPackage

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
id	string	Yes
replaceTenantPackageBody	ReplaceTenantPackageBody	Yes

Odgovor

Vrne: APIEmptyResponse

Primer

replaceTenantPackage Primer

Copy

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

updateTenantPackage

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
id	string	Da
updateTenantPackageBody	UpdateTenantPackageBody	Da

Odziv

Vrne: APIEmptyResponse

Primer

updateTenantPackage Primer

Copy

auto body = std::make_shared<UpdateTenantPackageBody>();
body->packageId = utility::conversions::to_string_t("premium-plan");
body->expirationDate = utility::conversions::to_string_t("2025-12-31");
body->notes = boost::optional<utility::string_t>(utility::conversions::to_string_t("Upgraded package"));
api->updateTenantPackage(utility::conversions::to_string_t("my-tenant-123"),
                         utility::conversions::to_string_t("pkg-456"),
                         body)
    .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> task) {
        try {
            auto response = task.get();
            // uspešno rokovanje
        } catch (const std::exception& ex) {
            // rokovanje z napako
        }
    });

createTenantUser

Parametri

Name	Type	Required	Description
tenantId	string	Da
createTenantUserBody	CreateTenantUserBody	Da

Odgovor

Vrne: CreateTenantUserResponse

Primer

Primer createTenantUser

Copy

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

deleteTenantUser

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
id	string	Da
options	const DeleteTenantUserOptions&	Da

Odgovor

Vrne: APIEmptyResponse

Primer

deleteTenantUser Primer

Copy

DeleteTenantUserOptions options;
options.reason = boost::optional<utility::string_t>(U("User requested deletion"));
api->deleteTenantUser(U("my-tenant-123"), U("user@example.com"), options)
    .then([](std::shared_ptr<APIEmptyResponse> resp){
        (void)resp;
    });

getTenantUser

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vrne: GetTenantUserResponse

Primer

Primer getTenantUser

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user@example.com");
api->getTenantUser(tenantId, userId)
    .then([](pplx::task<std::shared_ptr<GetTenantUserResponse>> task) {
        try {
            auto response = task.get();
            // Uporabi odgovor po potrebi
        } catch (const std::exception&) {
            // Obdelava napake
        }
    });

getTenantUsers

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
skip	double	Ne

Odgovor

Vrne: GetTenantUsersResponse

Primer

Primer getTenantUsers

Copy

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

replaceTenantUser

Parametri

Name	Type	Required
tenantId	string	Yes
id	string	Yes
replaceTenantUserBody	ReplaceTenantUserBody	Yes
updateComments	string	No

Odgovor

Vrne: APIEmptyResponse

Primer

replaceTenantUser Primer

Copy

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

sendLoginLink

Parameters

Ime	Tip	Obvezno
tenantId	string	Da
id	string	Da
redirectURL	string	Ne

Response

Vrne: APIEmptyResponse

Example

sendLoginLink Primer

Copy

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

updateTenantUser

Parameters

Ime	Vrsta	Obvezno
tenantId	string	Yes
id	string	Yes
updateTenantUserBody	UpdateTenantUserBody	Yes
updateComments	string	No

Response

Vrne: APIEmptyResponse

Example

Primer updateTenantUser

Copy

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

createTenant

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
createTenantBody	CreateTenantBody	Da

Odziv

Vrnitev: CreateTenantResponse

Primer

createTenant Primer

Copy

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

deleteTenant

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
id	string	Yes
sure	string	No

Odgovor

Vrne: APIEmptyResponse

Primer

deleteTenant Primer

Copy

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

getTenant

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetTenantResponse

Example

Primer getTenant

Copy

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

getTenants

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Yes
options	const GetTenantsOptions&	Yes

Odgovor

Vrne: GetTenantsResponse

Primer

Primer getTenants

Copy

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

updateTenant

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
id	string	Yes
updateTenantBody	UpdateTenantBody	Yes

Odgovor

Vrne: APIEmptyResponse

Primer

updateTenant Primer

Copy

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

changeTicketState

Parametri

Ime	Tip	Obvezno
tenantId	string	Yes
userId	string	Yes
id	string	Yes
changeTicketStateBody	ChangeTicketStateBody	Yes

Odgovor

Vrne: ChangeTicketStateResponse

Primer

changeTicketState Primer

Copy

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

createTicket

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
userId	string	Yes
createTicketBody	CreateTicketBody	Yes

Odgovor

Vrne: CreateTicketResponse

Primer

Primer createTicket

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("john.doe@example.com");
CreateTicketBody ticketBody;
ticketBody.setSubject(utility::conversions::to_string_t("Login Issue"));
ticketBody.setDescription(utility::conversions::to_string_t("Cannot log in after password reset."));
boost::optional<int> priority = 2;
ticketBody.setPriority(priority);
api->createTicket(tenantId, userId, ticketBody).then([](pplx::task<std::shared_ptr<CreateTicketResponse>> task){
    try{
        auto response = task.get();
        // Uporabi odgovor po potrebi
    }catch(const std::exception&){
        // Obdelaj napako
    }
});

getTicket

Parametri

Ime	Tip	Potrebno
tenantId	string	Yes
id	string	Yes
userId	string	No

Odgovor

Vrne: GetTicketResponse

Primer

Primer getTicket

Copy

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

getTickets

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
options	const GetTicketsOptions&	Da

Odgovor

Vrne: GetTicketsResponse

Primer

Primer getTickets

Copy

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

getTranslations

Parametri

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

Odgovor

Vrne: GetTranslationsResponse

Primer

Primer getTranslations

Copy

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

uploadImage

Naloži in spremeni velikost slike

Parametri

Ime	Tip	Obvezno
tenantId	string	Yes
file	HttpContent	Yes
options	const UploadImageOptions&	Yes

Odgovor

Returns: UploadImageResponse

Primer

uploadImage Primer

Copy

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

getUserBadgeProgressById

Parametri

Ime	Tip	Potrebno	Opis
tenantId	string	Da
id	string	Da

Odziv

Vrne: APIGetUserBadgeProgressResponse

Primer

getUserBadgeProgressById Primer

Copy

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

getUserBadgeProgressByUserId

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
userId	string	Yes

Odziv

Vrne: APIGetUserBadgeProgressResponse

Primer

getUserBadgeProgressByUserId Primer

Copy

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

getUserBadgeProgressList

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
options	const GetUserBadgeProgressListOptions&	Yes

Odgovor

Vrne: APIGetUserBadgeProgressListResponse

Primer

Primer getUserBadgeProgressList

Copy

utility::string_t tenantId = U("my-tenant-123");
GetUserBadgeProgressListOptions options;
options.userId = U("user@example.com");
options.page = boost::optional<int>(1);
options.pageSize = boost::optional<int>(20);
api->getUserBadgeProgressList(tenantId, options)
    .then([](std::shared_ptr<APIGetUserBadgeProgressListResponse> resp) {
        if (!resp) return;
        for (const auto& badge : resp->badges) {
            // obdelaj značko
        }
    });

createUserBadge

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
createUserBadgeParams	CreateUserBadgeParams	Da

Odgovor

Vrne: APICreateUserBadgeResponse

Primer

createUserBadge Primer

Copy

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

deleteUserBadge

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vrne: APIEmptySuccessResponse

Primer

deleteUserBadge Primer

Copy

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

getUserBadge

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
id	string	Yes

Odgovor

Vrne: APIGetUserBadgeResponse

Primer

Primer getUserBadge

Copy

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

getUserBadges

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
options	const GetUserBadgesOptions&	Yes

Odgovor

Vrne: APIGetUserBadgesResponse

Primer

Primer getUserBadges

Copy

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

updateUserBadge

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
id	string	Da
updateUserBadgeParams	UpdateUserBadgeParams	Da

Odgovor

Vrne: APIEmptySuccessResponse

Primer

Primer updateUserBadge

Copy

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

getUserNotificationCount

Parametri

Ime	Vrsta	Obvezno	Opis
tenantId	string	Da
sso	string	Ne

Odgovor

Vrne: GetUserNotificationCountResponse

Primer

Primer getUserNotificationCount

Copy

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

getUserNotifications

Parametri

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

Odgovor

Vrne: GetMyNotificationsResponse

Primer

getUserNotifications Primer

Copy

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

resetUserNotificationCount

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Yes
sso	string	No

Odgovor

Vrne: ResetUserNotificationsResponse

Primer

resetUserNotificationCount Primer

Copy

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

resetUserNotifications

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
options	const ResetUserNotificationsOptions&	Da

Odgovor

Vrne: ResetUserNotificationsResponse

Primer

Primer resetUserNotifications

Copy

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

updateUserNotificationCommentSubscriptionStatus

Omogočite ali onemogočite obvestila za določen komentar.

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
notificationId	string	Yes
optedInOrOut	string	Yes
commentId	string	Yes
sso	string	No

Odgovor

Vrne: UpdateUserNotificationCommentSubscriptionStatusResponse

Primer

updateUserNotificationCommentSubscriptionStatus Primer

Copy

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

updateUserNotificationPageSubscriptionStatus

Omogoči ali onemogoči obvestila za stran. Ko so uporabniki naročeni na stran, se ustvarjajo obvestila za nove korenske komentarje, ter tudi

Parametri

Ime	Tip	Obvezno
tenantId	string	Yes
urlId	string	Yes
url	string	Yes
pageTitle	string	Yes
subscribedOrUnsubscribed	string	Yes
sso	string	No

Odgovor

Vrne: UpdateUserNotificationPageSubscriptionStatusResponse

Primer

updateUserNotificationPageSubscriptionStatus Primer

Copy

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

updateUserNotificationStatus

Parametri

Ime	Tip	Obvezno
tenantId	string	Yes
notificationId	string	Yes
newStatus	string	Yes
sso	string	No

Odgovor

Vrne: UpdateUserNotificationStatusResponse

Primer

updateUserNotificationStatus Primer

Copy

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

getUserPresenceStatuses

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Yes
urlIdWS	string	Yes
userIds	string	Yes

Odgovor

Vrne: GetUserPresenceStatusesResponse

Primer

getUserPresenceStatuses Primer

Copy

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

searchUsers

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
urlId	string	Da
options	const SearchUsersOptions&	Da

Odgovor

Vrne: SearchUsersResult

Primer

Primer searchUsers

Copy

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

getUser

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
id	string	Da

Odgovor

Vrne: GetUserResponse

Primer

Primer getUser

Copy

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

createVote

Parametri

Ime	Tip	Obvezno
tenantId	string	Da
commentId	string	Da
direction	string	Da
options	const CreateVoteOptions&	Da

Odgovor

Vrne: VoteResponse

Primer

createVote Primer

Copy

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

deleteVote

Parametri

Ime	Tip	Obvezno
tenantId	string	Yes
id	string	Yes
editKey	string	No

Odgovor

Vrne: VoteDeleteResponse

Primer

deleteVote Primer

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto voteId = utility::conversions::to_string_t("vote-9876");
boost::optional<utility::string_t> editKey = utility::conversions::to_string_t("edit-abc123");
api->deleteVote(tenantId, voteId, editKey).then([](pplx::task<std::shared_ptr<VoteDeleteResponse>> task) {
    try {
        auto response = task.get();
        // Process response as needed
    } catch (const std::exception&) {
        // Handle error
    }
});

getVotes

Parametri

Ime	Tip	Obvezno	Opis
tenantId	string	Da
urlId	string	Da

Odgovor

Vrne: GetVotesResponse

Primer

Primer getVotes

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto urlId = utility::string_t(U("article-456"));
boost::optional<utility::string_t> extraHeader = boost::none;
api->getVotes(tenantId, urlId).then([=](pplx::task<std::shared_ptr<GetVotesResponse>> task) {
    try {
        auto original = task.get();
        auto response = std::make_shared<GetVotesResponse>(*original);
    } catch (...) {
        // obdelava napake
    }
});

getVotesForUser

Parametri

Ime	Vrsta	Obvezno
tenantId	string	Da
urlId	string	Da
options	const GetVotesForUserOptions&	Da

Odgovor

Vrne: GetVotesForUserResponse

Primer

Primer getVotesForUser

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto urlId = utility::string_t(U("post-456"));
GetVotesForUserOptions options;
options.page = boost::optional<int>(2);
options.pageSize = boost::optional<int>(50);
api->getVotesForUser(tenantId, urlId, options).then([](std::shared_ptr<GetVotesForUserResponse> response) {
    if (response) {
        // obravnavaj odgovor, npr., preglej glasove
    }
});

Potrebujete pomoč?

Če naletite na težave ali imate vprašanja glede C++ SDK, prosimo:

Prispevanje

Prispevki so dobrodošli! Prosimo, obiščite GitHub repozitorij za smernice za prispevanje.

Jezik 🇸🇮 Slovenščina

Dokumentacija

Začetek

Referenca API

Uporaba

Agregacija

Dnevniki revizije

Avtentikacija

Blokiranje iz komentarja

Preverjanje blokiranih komentarjev

Komentarji

Komentarji za uporabnika

Nastavitve domene

E-poštne predloge

Dnevnik dogodkov

Objave vira

Označi komentar

GIFi

Hashtagi

Moderacija

Moderatorji

Število obvestil

Obvestila

Reakcije strani

Strani

Čakajoči webhook dogodki

Konfiguracije vprašanj

Rezultati vprašanj

Agregacija rezultatov vprašanj

SSO uporabniki

Naročnine

Dnevna uporaba najemnika

Paketi najemnika

Uporabniki najemnika

Najemniki

Vstopnice

Prevodi

Naloži sliko

Napredek značke uporabnika

Značke uporabnikov

Uporabniška obvestila

Status prisotnosti uporabnika

Iskanje uporabnikov

Uporabniki

Glasovi

FastComments SDK za C++

Repozitorij

Zahteve

Namestitev

Namestitev odvisnosti

Gradnja iz izvorne kode

Namestitev

Vsebina knjižnice

Javni in zavarovani API-ji

Hitri začetek

Uporaba avtenticiranih API-jev (DefaultAPI)

Uporaba javnih API-jev (PublicAPI)

Uporaba moderacijskih API-jev (ModerationApi)

Pogoste težave

Klici API: sinhroni proti asinhronim

Sinhroni klici z .get()

Asinhroni klici z .then()

Izbira med sinhronim in asinhronim

Opombe

Broadcast Ids

SSO (Enotna prijava)

Uporaba SSO

Preprost SSO

Varen SSO

Dokumentacija za fastcomments

Dokumentacija za API končne točke

Dokumentacija za modele

aggregate

Parameters

Response

Example

getAuditLogs

Parametri

Odgovor

Primer

Sinhroni klici z `.get()`

Asinhroni klici z `.then()`