FastComments C++ SDK

Dette er den officielle C++ SDK til FastComments.

Officiel C++ SDK til FastComments API'en

Repository

Krav

C++17 eller nyere
CMake 3.14 eller nyere
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (downloades automatisk til testning)

Installation

Installer afhængigheder

sudo apt install libcpprest-dev libboost-all-dev

Byg fra kildekode

mkdir build
cd build
cmake ..
make

Installation

sudo make install

Biblioteksindhold

Dette bibliotek indeholder den genererede API-klient og SSO‑værktøjerne, som gør arbejdet med API'en lettere.

API Client Library Docs

Offentlige vs sikrede API'er

For API‑klienten er der tre klasser, DefaultApi, PublicApi og ModerationApi. DefaultApi indeholder metoder, der kræver din API‑nøgle, og PublicApi indeholder
metoder, der kan kaldes direkte fra en browser/mobil enhed/osv uden godkendelse. ModerationApi leverer en omfattende suite af live og hurtige moderations‑API'er. Hver ModerationApi‑metode accepterer en sso‑parameter og kan godkendes via SSO eller en FastComments.com sessions‑cookie.

Hurtigstart

Brug af autentificerede API'er (DefaultAPI)

Vigtigt:

Du skal angive base‑URL’en (cpp‑restsdk‑generatoren læser den ikke fra OpenAPI‑specifikationen)
Du skal indstille din API‑nøgle på ApiClient, før du foretager autentificerede anmodninger. Hvis du ikke gør det, vil anmodninger fejle med en 401‑fejl.

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

    // KRÆVET: Indstil basis-URL'en (vælg din region)
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));  // US
    // ELLER: config->setBaseUrl(utility::conversions::to_string_t("https://eu.fastcomments.com"));  // EU

    // KRÆVET: Indstil din API-nøgle
    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);

    // Foretag nu godkendte API‑kald
    return 0;
}

Brug af offentlige API'er (PublicAPI)

Offentlige slutpunkter kræver ikke godkendelse:

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

    // KRÆVET: Indstil basis-URL'en
    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);

    // Foretag offentlige API‑kald
    return 0;
}

Brug af moderations‑API'er (ModerationApi)

ModerationApi driver moderator‑dashboardet. Hver metode accepterer en sso‑parameter, så kaldet udføres på vegne af en SSO‑godkendt moderator (se SSO‑sektionen nedenfor for, hvordan du opretter et token):

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

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

    // KRÆVET: Indstil basis-URL'en
    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);

    // Videregiv moderatorens SSO-token for at autentificere kaldet
    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;
}

Almindelige problemer

"URI skal indeholde et hostnavn"-fejl: Sørg for at kalde config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) før du opretter ApiClient. cpp‑restsdk‑generatoren læser ikke automatisk server‑URL’en fra OpenAPI‑specifikationen.
401 "missing-api-key"-fejl: Sørg for at kalde config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) før du opretter DefaultAPI‑instansen.
Forkert API‑klasse: Brug DefaultApi til server‑side autentificerede anmodninger, PublicApi til klient‑side/offentlige anmodninger, og ModerationApi til moderator‑dashboard‑anmodninger (godkendt med et moderator‑SSO‑token).

Foretage API-opkald: Synkront vs Asynkront

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.

Synkrone kald med `.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);

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

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

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

Asynkrone kald med `.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);

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

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

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

Valg mellem synkron og asynkron

The choice depends on your runtime environment and application architecture:

.get() (Synkron blokering)

Blokerer den kaldende tråd indtil HTTP-anmodningen er fuldført
Enklere kodeflow, lettere at forstå
Egnet til dedikerede worker-tråde, batchbehandling eller kommandolinjeværktøjer
Ikke egnet til event loops, GUI-tråde eller enkelttrådede servere

.then() (Asynkron ikke-blokerende)

Returnerer straks, callback udføres når anmodningen er fuldført
Blokerer ikke den kaldende tråd
Påkrævet for hændelsesdrevet arkitektur, GUI-applikationer eller enkelttrådede event loops
Tillader kædning af flere operationer
Mere komplekst kontrolflow

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

Noter

Broadcast-id'er

Du vil se, at du skal sende en broadcastId i nogle API-opkald. Når du modtager events, får du dette ID tilbage, så du kan ignorere eventet, hvis du planlægger at anvende ændringer optimistisk på klienten (hvilket du sandsynligvis vil gøre, da det giver den bedste oplevelse). Send en UUID her. ID'et bør være unikt nok til ikke at forekomme to gange i en browser-session.

SSO (Single Sign-On)

For SSO-eksempler, se nedenfor.

Brug af SSO

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

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

Dokumentation for fastcomments

Dokumentation for API-endpunkter

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

Klasse	Metode	HTTP-anmodning	Beskrivelse
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	Aggregerer dokumenter ved at gruppere dem (hvis groupBy er angivet) og anvende flere operationer. Forskellige operationer (f.eks. sum, countDistinct, avg osv.) understøttes.
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	Tidligere kommentatorer på siden, som IKKE er online i øjeblikket. Sorteret efter displayName. Brug dette efter at have udtømt /users/online for at vise et “Members”-afsnit. Cursor-paginering på commenterName: serveren går gennem den delvise {tenantId, urlId, commenterName}-indeks fra afterName fremad via $gt, uden $skip-omkostning.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	Aktuelt online‑besøgende på en side: personer, hvis websocket‑session er abonnér på siden lige nu. Returnerer anonCount + totalCount (rum‑omfattende abonnenter, inklusive anonyme seere vi ikke lister).
PublicApi	getPagesPublic	GET /pages/{tenantId}	Liste over sider for en lejer. Bruges af FChat‑desktop‑klienten til at udfylde sit rum‑oversigt. Kræver `enableFChat` at være sand på den løste brugerdefinerede konfiguration for hver side. Sider, der kræver SSO, filtreres i henhold til den anmodende brugers gruppeadgang.
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	Masse‑brugerinfo for en lejer. Givet bruger‑IDs returneres visningsinfo fra User/SSOUser. Bruges af kommentar‑widget’en til at berige brugere, som netop er dukket op via en tilstedeværelses‑begivenhed. Ingen side‑kontekst: privatliv håndhæves ensartet (private profiler maskeres).
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}	Aktiver eller deaktiver meddelelser for en specifik kommentar.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Aktiver eller deaktiver meddelelser for en side. Når brugere abonnerer på en side, oprettes meddelelser for nye rodrødder, og også
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Upload og ændr størrelse på et billede
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Dokumentation for modeller

aggregate

Aggregere dokumenter ved at gruppere dem (hvis groupBy er angivet) og anvende flere operationer.
Forskellige operationer (f.eks. sum, countDistinct, avg osv.) understøttes.

Parameters

Navn	Type	Påkrævet
tenantId	string	Ja
aggregationRequest	AggregationRequest	Ja
options	const AggregateOptions&	Ja

Response

Returnerer: AggregateResponse

Example

aggreger Eksempel

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();
            // behandl svar
        } catch (const std::exception& e) {
            // håndter fejl
        }
    });

getAuditLogs

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const GetAuditLogsOptions&	Ja

Svar

Returnerer: GetAuditLogsResponse

Eksempel

getAuditLogs Eksempel

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();
        // brug svar
    } catch (const std::exception& e) {
        // håndter fejl
    }
});

logoutPublic

Svar

Returnerer: APIEmptyResponse

Eksempel

logoutPublic Eksempel

Copy

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
commentId	string	Yes
publicBlockFromCommentParams	PublicBlockFromCommentParams	Yes
sso	string	No

Svar

Returnerer: BlockSuccess

Eksempel

blockFromCommentPublic Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
commentId	string	Yes
publicBlockFromCommentParams	PublicBlockFromCommentParams	Yes
sso	string	No

Svar

Returnerer: UnblockSuccess

Eksempel

unBlockCommentPublic Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
commentIds	string	Yes
sso	string	No

Svar

Returnerer: CheckBlockedCommentsResponse

Eksempel

checkedCommentsForBlocked Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
id	string	Yes
blockFromCommentParams	BlockFromCommentParams	Yes
options	const BlockUserFromCommentOptions&	Yes

Svar

Returnerer: BlockSuccess

Eksempel

blockUserFromComment Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
urlId	string	Ja
broadcastId	string	Ja
commentData	CommentData	Ja
options	const CreateCommentPublicOptions&	Ja

Respons

Returnerer: SaveCommentsResponseWithPresence

Eksempel

createCommentPublic Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
options	const DeleteCommentOptions&	Ja

Svar

Returnerer: DeleteCommentResult

Eksempel

deleteComment Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
commentId	string	Ja
broadcastId	string	Ja
options	const DeleteCommentPublicOptions&	Ja

Svar

Returnerer: PublicAPIDeleteCommentResponse

Eksempel

deleteCommentPublic Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
commentId	string	Ja
voteId	string	Ja
urlId	string	Ja
broadcastId	string	Ja
options	const DeleteCommentVoteOptions&	Ja

Svar

Returnerer: VoteDeleteResponse

Eksempel

deleteCommentVote Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
id	string	Yes
options	const FlagCommentOptions&	Yes

Svar

Returnerer: FlagCommentResponse

Eksempel

flagComment Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
id	string	Ja

Svar

Returnerer: APIGetCommentResponse

Eksempel

getComment Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const GetCommentsOptions&	Ja

Svar

Returnerer: APIGetCommentsResponse

Eksempel

getComments Eksempel

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();
        // brug svaret efter behov
    } catch (const std::exception& e) {
        // håndtér fejl
    }
});

getCommentsPublic

req tenantId urlId

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
urlId	string	Ja
options	const GetCommentsPublicOptions&	Ja

Svar

Returnerer: GetCommentsResponseWithPresence_PublicComment_

Eksempel

getCommentsPublic Eksempel

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

Parametre

Navn	Type	Krævet
tenantId	string	Yes
commentId	string	Yes
options	const GetCommentTextOptions&	Yes

Svar

Returnerer: PublicAPIGetCommentTextResponse

Eksempel

getCommentText Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
commentId	string	Yes
dir	int32_t	Yes
sso	string	No

Svar

Returnerer: GetCommentVoteUserNamesSuccessResponse

Eksempel

getCommentVoteUserNames Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
commentId	string	Ja
broadcastId	string	Ja
sso	string	Nej

Respons

Returnerer: APIEmptyResponse

Eksempel

lockComment Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
commentId	string	Ja
broadcastId	string	Ja
sso	string	Nej

Svar

Returnerer: ChangeCommentPinStatusResponse

Eksempel

pinComment Eksempel

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

saveComment

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
createCommentParams	CreateCommentParams	Ja
options	const SaveCommentOptions&	Ja

Svar

Returnerer: APISaveCommentResponse

Eksempel

saveComment Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
commentTextUpdateRequest	CommentTextUpdateRequest	Yes
options	const SetCommentTextOptions&	Yes

Svar

Returnerer: PublicAPISetCommentTextResponse

Eksempel

setCommentText Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
unBlockFromCommentParams	UnBlockFromCommentParams	Ja
options	const UnBlockUserFromCommentOptions&	Ja

Svar

Returnerer: UnblockSuccess

Eksempel

unBlockUserFromComment Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
options	const UnFlagCommentOptions&	Ja

Svar

Returnerer: FlagCommentResponse

Eksempel

unFlagComment Eksempel

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;
            // behandl status om nødvendigt
        }
    })
    .then([](pplx::task<void> previous) {
        try {
            previous.get();
        } catch (const std::exception& e) {
            // håndter fejl
        }
    });

unLockComment

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Svar

Returnerer: APIEmptyResponse

Eksempel

unLockComment Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Svar

Returnerer: ChangeCommentPinStatusResponse

Eksempel

unPinComment Eksempel

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

Parametre

Navn	Type	Obligatorisk
tenantId	string	Yes
id	string	Yes
updatableCommentParams	UpdatableCommentParams	Yes
options	const UpdateCommentOptions&	Yes

Svar

Returnerer: APIEmptyResponse

Eksempel

updateComment Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
commentId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
voteBodyParams	VoteBodyParams	Yes
options	const VoteCommentOptions&	Yes

Respons

Returnerer: VoteResponse

Eksempel

voteComment Eksempel

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();
           // behandl svar
       } catch (const std::exception&) {
       }
   });

getCommentsForUser

Parametre

Navn	Type	Påkrævet	Beskrivelse
options	const GetCommentsForUserOptions&	Ja

Svar

Returnerer: GetCommentsForUserResponse

Eksempel

getCommentsForUser Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
addDomainConfigParams	AddDomainConfigParams	Ja

Svar

Returnerer: AddDomainConfigResponse

Eksempel

addDomainConfig Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
domain	string	Yes

Svar

Returns: DeleteDomainConfigResponse

Eksempel

deleteDomainConfig Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
domain	string	Yes

Svar

Returnerer: GetDomainConfigResponse

Eksempel

getDomainConfig Eksempel

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) {
            // håndter aktiveret moderation
        }
        if (theme) {
            // brug tema værdi
        }
    })
    .wait();

getDomainConfigs

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes

Svar

Returnerer: GetDomainConfigsResponse

Eksempel

getDomainConfigs Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
domainToUpdate	string	Yes
patchDomainConfigParams	PatchDomainConfigParams	Yes

Svar

Returnerer: PatchDomainConfigResponse

Eksempel

patchDomainConfig Eksempel

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) {
        // håndtering af succes
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* fejlbehandling */ }
    });

putDomainConfig

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
domainToUpdate	string	Yes
updateDomainConfigParams	UpdateDomainConfigParams	Yes

Svar

Returnerer: PutDomainConfigResponse

Eksempel

putDomainConfig Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
createEmailTemplateBody	CreateEmailTemplateBody	Yes

Svar

Returnerer: CreateEmailTemplateResponse

Eksempel

createEmailTemplate Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
id	string	Yes

Svar

Returnerer: APIEmptyResponse

Eksempel

deleteEmailTemplate Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
errorId	string	Ja

Svar

Returnerer: APIEmptyResponse

Eksempel

deleteEmailTemplateRenderError Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
id	string	Ja

Svar

Returnerer: GetEmailTemplateResponse

Eksempel

getEmailTemplate Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja

Svar

Returnerer: GetEmailTemplateDefinitionsResponse

Eksempel

Eksempel på 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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
skip	double	Nej

Svar

Returnerer: GetEmailTemplateRenderErrorsResponse

Eksempel

getEmailTemplateRenderErrors Eksempel

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();
            // Brug svaret efter behov
        } catch (const std::exception& ex) {
            // Håndter fejl
        }
    });

getEmailTemplates

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
skip	double	Nej

Svar

Returnerer: GetEmailTemplatesResponse

Eksempel

getEmailTemplates Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
renderEmailTemplateBody	RenderEmailTemplateBody	Ja
locale	string	Nej

Svar

Returnerer: RenderEmailTemplateResponse

Eksempel

renderEmailTemplate Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
updateEmailTemplateBody	UpdateEmailTemplateBody	Ja

Respons

Returnerer: APIEmptyResponse

Eksempel

updateEmailTemplate Eksempel

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

getEventLog

req tenantId urlId userIdWS

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
urlId	string	Ja
userIdWS	string	Ja
startTime	int64_t	Ja
endTime	int64_t	Nej

Svar

Returnerer: GetEventLogResponse

Eksempel

getEventLog Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
urlId	string	Ja
userIdWS	string	Ja
startTime	int64_t	Ja
endTime	int64_t	Nej

Svar

Returnerer: GetEventLogResponse

Eksempel

getGlobalEventLog Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
options	const CreateFeedPostOptions&	Yes

Svar

Returnerer: CreateFeedPostsResponse

Eksempel

createFeedPost Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
createFeedPostParams	CreateFeedPostParams	Ja
options	const CreateFeedPostPublicOptions&	Ja

Svar

Returnerer: CreateFeedPostResponse

Eksempel

createFeedPostPublic Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
postId	string	Ja
options	const DeleteFeedPostPublicOptions&	Ja

Svar

Returnerer: DeleteFeedPostPublicResponse

Eksempel

deleteFeedPostPublic Eksempel

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

getFeedPosts

req tenantId afterId

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const GetFeedPostsOptions&	Ja

Svar

Returnerer: GetFeedPostsResponse

Eksempel

getFeedPosts Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const GetFeedPostsPublicOptions&	Ja

Svar

Returnerer: PublicFeedPostsResponse

Eksempel

getFeedPostsPublic Eksempel

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);
        // Brug den behandlede som nødvendig
    }catch(const std::exception&){
        // Håndter fejl
    }
});

getFeedPostsStats

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
postIds	vector<string	Yes
sso	string	No

Svar

Returnerer: FeedPostsStatsResponse

Eksempel

getFeedPostsStats Eksempel

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

Parametre

Name	Type	Required	Description
tenantId	string	Ja
options	const GetUserReactsPublicOptions&	Ja

Svar

Returnerer: UserReactsResponse

Eksempel

getUserReactsPublic Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
postId	string	Ja
reactBodyParams	ReactBodyParams	Ja
options	const ReactFeedPostPublicOptions&	Ja

Svar

Returnerer: ReactFeedPostResponse

Eksempel

reactFeedPostPublic Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
feedPost	FeedPost	Ja

Svar

Returnerer: APIEmptyResponse

Eksempel

updateFeedPost Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
postId	string	Yes
updateFeedPostParams	UpdateFeedPostParams	Yes
options	const UpdateFeedPostPublicOptions&	Yes

Svar

Returnerer: CreateFeedPostResponse

Eksempel

updateFeedPostPublic Eksempel

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

Parametre

Navn	Type	Obligatorisk
tenantId	string	Ja
commentId	string	Ja
isFlagged	bool	Ja
sso	string	Nej

Response

Returnerer: APIEmptyResponse

Eksempel

flagCommentPublic Eksempel

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

Parametre

Navn	Type	Obligatorisk	Beskrivelse
tenantId	string	Ja
largeInternalURLSanitized	string	Ja

Svar

Returnerer: GifGetLargeResponse

Eksempel

getGifLarge Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
search	string	Yes
options	const GetGifsSearchOptions&	Yes

Svar

Returnerer: GetGifsSearchResponse

Eksempel

getGifsSearch Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const GetGifsTrendingOptions&	Ja

Respons

Returnerer: GetGifsTrendingResponse

Eksempel

getGifsTrending Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
createHashTagBody	CreateHashTagBody	Yes

Svar

Returnerer: CreateHashTagResponse

Eksempel

addHashTag Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Ja

Svar

Returnerer: BulkCreateHashTagsResponse

Eksempel

addHashTagsBulk Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
tag	string	Yes
deleteHashTagRequestBody	DeleteHashTagRequestBody	Yes

Svar

Returnerer: APIEmptyResponse

Eksempel

deleteHashTag Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
page	double	No

Svar

Returnerer: GetHashTagsResponse

Eksempel

getHashTags Eksempel

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);
        // brug svar
    } catch (const std::exception&) {
        // håndter fejl
    }
});

patchHashTag

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
tag	string	Yes
updateHashTagBody	UpdateHashTagBody	Yes

Svar

Returnerer: UpdateHashTagResponse

Eksempel

patchHashTag Eksempel

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

Parametre

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
voteId	string	Yes
options	const DeleteModerationVoteOptions&	Yes

Respons

Returnerer: VoteDeleteResponse

Eksempel

deleteModerationVote Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const GetApiCommentsOptions&	Ja

Svar

Returnerer: ModerationAPIGetCommentsResponse

Eksempel

getApiComments Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const GetApiExportStatusOptions&	Ja

Svar

Returnerer: ModerationExportStatusResponse

Eksempel

getApiExportStatus Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const GetApiIdsOptions&	Ja

Respons

Returnerer: ModerationAPIGetCommentIdsResponse

Eksempel

getApiIds Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
commentId	string	Ja
sso	string	Nej

Svar

Returnerer: GetBannedUsersFromCommentResponse

Eksempel

getBanUsersFromComment eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
commentId	string	Ja
sso	string	Nej

Svar

Returnerer: GetCommentBanStatusResponse

Eksempel

getCommentBanStatus Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Svar

Returnerer: ModerationAPIChildCommentsResponse

Eksempel

getCommentChildren Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const GetCountOptions&	Ja

Svar

Returnerer: ModerationAPICountCommentsResponse

Eksempel

getCount Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
sso	string	Nej

Svar

Returnerer: GetBannedUsersCountResponse

Eksempel

getCounts Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Svar

Returnerer: ModerationAPIGetLogsResponse

Eksempel

getLogs Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
sso	string	No

Svar

Returnerer: GetTenantManualBadgesResponse

Eksempel

getManualBadges Eksempel

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();
            // behandl respons, f.eks. response->badgeList
        } catch (const std::exception& ex) {
            // håndter fejl
        }
    });

getManualBadgesForUser

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const GetManualBadgesForUserOptions&	Ja

Svar

Returnerer: GetUserManualBadgesResponse

Eksempel

getManualBadgesForUser Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
commentId	string	Ja
options	const GetModerationCommentOptions&	Ja

Svar

Returnerer: ModerationAPICommentResponse

Eksempel

getModerationComment Eksempel

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();
            // Behandl svaret efter behov
        } catch (const std::exception& ex) {
            // Håndter fejl
        }
    });

getModerationCommentText

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
commentId	string	Ja
sso	string	Nej

Svar

Returnerer: GetCommentTextResponse

Eksempel

getModerationCommentText Eksempel

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

Parameters

Navn	Type	Påkrævet
tenantId	string	Ja
commentId	string	Ja
options	const GetPreBanSummaryOptions&	Ja

Response

Returnerer: PreBanSummary

Eksempel

getPreBanSummary Eksempel

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();
            // behandle opsummering
        } catch (const std::exception&) {
            // håndter fejl
        }
    });

getSearchCommentsSummary

Parametre

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

Respons

Returnerer: ModerationCommentSearchResponse

Eksempel

getSearchCommentsSummary Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const GetSearchPagesOptions&	Ja

Svar

Returnerer: ModerationPageSearchResponse

Eksempel

getSearchPages Eksempel

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();
            // brug svar
        } catch (const std::exception& e) {
            // håndter fejl
        }
    });

getSearchSites

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
options	const GetSearchSitesOptions&	Yes

Svar

Returnerer: ModerationSiteSearchResponse

Eksempel

getSearchSites Eksempel

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) {
               // behandlingslogik
           }
       } catch (const std::exception&) {
           // fejlhåndtering
       }
   });

getSearchSuggest

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const GetSearchSuggestOptions&	Ja

Svar

Returnerer: ModerationSuggestResponse

Eksempel

getSearchSuggest Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const GetSearchUsersOptions&	Ja

Svar

Returnerer: ModerationUserSearchResponse

Eksempel

getSearchUsers Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
options	const GetTrustFactorOptions&	Yes

Svar

Returnerer: GetUserTrustFactorResponse

Eksempel

getTrustFactor Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
sso	string	Nej

Svar

Returnerer: APIModerateGetUserBanPreferencesResponse

Eksempel

getUserBanPreference Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
options	const GetUserInternalProfileOptions&	Yes

Svar

Returnerer: GetUserInternalProfileResponse

Eksempel

getUserInternalProfile Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
commentId	string	Ja
adjustCommentVotesParams	AdjustCommentVotesParams	Ja
options	const PostAdjustCommentVotesOptions&	Ja

Response

Returnerer: AdjustVotesResponse

Eksempel

postAdjustCommentVotes Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const PostApiExportOptions&	Ja

Svar

Returnerer: ModerationExportResponse

Eksempel

postApiExport Eksempel

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) {
            // håndter vellykket eksportrespons
        }
    })
    .wait();

postBanUserFromComment

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
commentId	string	Ja
options	const PostBanUserFromCommentOptions&	Ja

Respons

Returnerer: BanUserFromCommentResult

Eksempel

postBanUserFromComment Eksempel

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

postBanUserUndo

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
banUserUndoParams	BanUserUndoParams	Yes
sso	string	No

Svar

Returnerer: APIEmptyResponse

Eksempel

postBanUserUndo Eksempel

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

postBulkPreBanSummary

Parametre

Name	Type	Required
tenantId	string	Ja
bulkPreBanParams	BulkPreBanParams	Ja
options	const PostBulkPreBanSummaryOptions&	Ja

Svar

Returnerer: BulkPreBanSummary

Eksempel

postBulkPreBanSummary Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
commentsByIdsParams	CommentsByIdsParams	Yes
sso	string	No

Svar

Returnerer: ModerationAPIChildCommentsResponse

Eksempel

postCommentsByIds Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
commentId	string	Yes
options	const PostFlagCommentOptions&	Yes

Svar

Returnerer: APIEmptyResponse

Eksempel

postFlagComment Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
commentId	string	Ja
options	const PostRemoveCommentOptions&	Ja

Svar

Returnerer: PostRemoveCommentApiResponse

Eksempel

postRemoveComment Eksempel

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();
            // Behandl svar
        } catch (const std::exception& ex) {
            // Håndter fejl
        }
    });

postRestoreDeletedComment

Parametre

Navn	Type	Obligatorisk
tenantId	string	Yes
commentId	string	Yes
options	const PostRestoreDeletedCommentOptions&	Yes

Svar

Returnerer: APIEmptyResponse

Eksempel

postRestoreDeletedComment Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
commentId	string	Ja
options	const PostSetCommentApprovalStatusOptions&	Ja

Respons

Returnerer: SetCommentApprovedResponse

Eksempel

postSetCommentApprovalStatus Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
commentId	string	Ja
options	const PostSetCommentReviewStatusOptions&	Ja

Svar

Returnerer: APIEmptyResponse

Eksempel

postSetCommentReviewStatus Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentSpamStatusOptions&	Yes

Svar

Returnerer: APIEmptyResponse

Eksempel

postSetCommentSpamStatus Eksempel

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

Parametre

Navn	Type	Krævet
tenantId	string	Ja
commentId	string	Ja
setCommentTextParams	SetCommentTextParams	Ja
options	const PostSetCommentTextOptions&	Ja

Svar

Returnerer: SetCommentTextResponse

Eksempel

postSetCommentText Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
commentId	string	Ja
options	const PostUnFlagCommentOptions&	Ja

Respons

Returnerer: APIEmptyResponse

Eksempel

postUnFlagComment Eksempel

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) {
        // behandling kan udføres her
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

postVote

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
commentId	string	Ja
options	const PostVoteOptions&	Ja

Svar

Returnerer: VoteResponse

Eksempel

postVote Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
badgeId	string	Ja
options	const PutAwardBadgeOptions&	Ja

Svar

Returnerer: AwardUserBadgeResponse

Eksempel

putAwardBadge Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
urlId	string	Ja
sso	string	Nej

Response

Returnerer: APIEmptyResponse

Eksempel

putCloseThread Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
badgeId	string	Ja
options	const PutRemoveBadgeOptions&	Ja

Svar

Returnerer: RemoveUserBadgeResponse

Eksempel

putRemoveBadge Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
urlId	string	Ja
sso	string	Nej

Svar

Returnerer: APIEmptyResponse

Eksempel

putReopenThread Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
options	const SetTrustFactorOptions&	Yes

Svar

Returnerer: SetUserTrustFactorResponse

Eksempel

setTrustFactor Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
createModeratorBody	CreateModeratorBody	Ja

Svar

Returnerer: CreateModeratorResponse

Eksempel

createModerator Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
sendEmail	string	Nej

Svar

Returnerer: APIEmptyResponse

Eksempel

deleteModerator Eksempel

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) {
        // håndter succes
    });

getModerator

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
id	string	Ja

Svar

Returnerer: GetModeratorResponse

Eksempel

getModerator Eksempel

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

Parametre

Navn	Type	Krævet	Beskrivelse
tenantId	string	Ja
skip	double	Nej

Svar

Returnerer: GetModeratorsResponse

Eksempel

getModerators Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
id	string	Yes
fromName	string	Yes

Respons

Returnerer: APIEmptyResponse

Eksempel

sendInvite Eksempel

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) {
    // håndter vellykket invitation
});

updateModerator

Parameters

Navn	Type	Påkrævet
tenantId	string	Yes
id	string	Yes
updateModeratorBody	UpdateModeratorBody	Yes

Response

Returnerer: APIEmptyResponse

Example

updateModerator Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
id	string	Ja

Svar

Returnerer: APIEmptyResponse

Eksempel

deleteNotificationCount Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
id	string	Yes

Svar

Returnerer: GetCachedNotificationCountResponse

Eksempel

getCachedNotificationCount Eksempel

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();
            // behandl svar
        } catch (const std::exception&) {
            // håndter fejl
        }
    });

getNotificationCount

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
options	const GetNotificationCountOptions&	Yes

Svar

Returnerer: GetNotificationCountResponse

Eksempel

getNotificationCount Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
options	const GetNotificationsOptions&	Yes

Svar

Returnerer: GetNotificationsResponse

Eksempel

getNotifications Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
updateNotificationBody	UpdateNotificationBody	Ja
userId	string	Nej

Svar

Returnerer: APIEmptyResponse

Eksempel

updateNotification Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
urlId	string	Ja
title	string	Nej

Svar

Returnerer: CreateV1PageReact

Eksempel

createV1PageReact Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
urlId	string	Ja
id	string	Ja
title	string	Nej

Svar

Returnerer: CreateV1PageReact

Eksempel

createV2PageReact Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
urlId	string	Yes

Svar

Returnerer: CreateV1PageReact

Eksempel

deleteV1PageReact Eksempel

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

Parametre

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

Svar

Returnerer: CreateV1PageReact

Eksempel

deleteV2PageReact Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
urlId	string	Yes

Response

Returnerer: GetV1PageLikes

Eksempel

getV1PageLikes Eksempel

Copy

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

getV2PageReacts

Parameters

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
urlId	string	Yes

Response

Returnerer: GetV2PageReacts

Example

getV2PageReacts Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
urlId	string	Yes
id	string	Yes

Svar

Returnerer: GetV2PageReactUsersResponse

Eksempel

getV2PageReactUsers Eksempel

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();
        // Brug responsen efter behov
    }catch(const std::exception&){
        // Håndter fejl
    }
});

addPage

Parametre

Name	Type	Required	Description
tenantId	string	Yes
createAPIPageData	CreateAPIPageData	Yes

Svar

Returnerer: AddPageAPIResponse

Eksempel

addPage Eksempel

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) {
            // håndter succesfuld tilføjelse
        } else {
            // håndter fejl
        }
    });

deletePage

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
id	string	Yes

Svar

Returnerer: DeletePageAPIResponse

Eksempel

deletePage Eksempel

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();
           // behandl svar efter behov
       } catch (const std::exception& ex) {
           // håndter fejl
       }
   });

getOfflineUsers

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

Parameters

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

Response

Returns: PageUsersOfflineResponse

Example

getOfflineUsers Eksempel

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

Aktuelt-online seere af en side: personer, hvis websocket‑session er abonneret på siden lige nu.
Returnerer anonCount + totalCount (rum‑bred abonnenter, inklusive anonyme seere, som vi ikke tæller).

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
urlId	string	Ja
options	const GetOnlineUsersOptions&	Ja

Svar

Returnerer: PageUsersOnlineResponse

Eksempel

getOnlineUsers Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
urlId	string	Ja

Svar

Returnerer: GetPageByURLIdAPIResponse

Eksempel

getPageByURLId Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes

Svar

Returnerer: GetPagesAPIResponse

Eksempel

getPages Eksempel

Copy

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

getPagesPublic

List sider for en lejer. Bruges af FChat‑desktopklienten til at udfylde sin rumliste.
Kræver enableFChat at være sand på den løste brugerdefinerede konfiguration for hver side.
Sider, der kræver SSO, filtreres i forhold til den anmodende brugers gruppeadgang.

Parameters

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const GetPagesPublicOptions&	Ja

Response

Returns: GetPublicPagesResponse

Example

getPagesPublic Eksempel

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();
        // behandle svar om nødvendigt
    }catch(const std::exception&){
        // håndter fejl om nødvendigt
    }
});

getUsersInfo

Bulk brugerinfo for en lejer. Givet userIds returneres visningsinfo fra User / SSOUser.
Brugt af kommentarfunktionen til at berige brugere, der netop er dukket op via en tilstedeværelseshændelse.
Ingen sidekontekst: privatliv håndhæves ensartet (private profiler maskeres).

Parameters

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
ids	string	Yes

Response

Returns: PageUsersInfoResponse

Example

getUsersInfo Eksempel

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();
        // behandl svar
    }catch(const std::exception&){
        // håndtér fejl
    }
});

patchPage

Parametre

Navn	Type	Krævet
tenantId	string	Ja
id	string	Ja
updateAPIPageData	UpdateAPIPageData	Ja

Svar

Returnerer: PatchPageAPIResponse

Eksempel

patchPage Eksempel

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

deletePendingWebhookEvent

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
id	string	Ja

Svar

Returnerer: APIEmptyResponse

Eksempel

deletePendingWebhookEvent Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
options	const GetPendingWebhookEventCountOptions&	Yes

Svar

Returnerer: GetPendingWebhookEventCountResponse

Eksempel

getPendingWebhookEventCount Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
options	const GetPendingWebhookEventsOptions&	Yes

Svar

Returnerer: GetPendingWebhookEventsResponse

Eksempel

getPendingWebhookEvents Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
createQuestionConfigBody	CreateQuestionConfigBody	Yes

Svar

Returnerer: CreateQuestionConfigResponse

Eksempel

createQuestionConfig Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
id	string	Yes

Svar

Returnerer: APIEmptyResponse

Eksempel

deleteQuestionConfig Eksempel

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) {
        // håndter vellykket sletning
    })
    .then([](pplx::task<void> t) {
        try {
            t.get();
        } catch (const std::exception&) {
            // håndter fejl
        }
    });

getQuestionConfig

Parametre

Navn	Type	Obligatorisk	Beskrivelse
tenantId	string	Ja
id	string	Ja

Svar

Returnerer: GetQuestionConfigResponse

Eksempel

getQuestionConfig Eksempel

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();
            // Brug svaret efter behov
        } catch (const std::exception&) {
            // Håndter fejl
        }
    });

getQuestionConfigs

Parametre

Navn	Type	Obligatorisk	Beskrivelse
tenantId	string	Ja
skip	double	Nej

Svar

Returnerer: GetQuestionConfigsResponse

Eksempel

getQuestionConfigs Eksempel

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

Parametre

Navn	Type	Krævet
tenantId	string	Ja
id	string	Ja
updateQuestionConfigBody	UpdateQuestionConfigBody	Ja

Respons

Returnerer: APIEmptyResponse

Eksempel

updateQuestionConfig Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
createQuestionResultBody	CreateQuestionResultBody	Ja

Svar

Returnerer: CreateQuestionResultResponse

Eksempel

createQuestionResult Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
id	string	Yes

Svar

Returnerer: APIEmptyResponse

Eksempel

deleteQuestionResult Eksempel

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();
                // succesbehandling
            }
            catch ( const std::exception& e )
            {
                // fejlhåndtering
            }
        } );
}

getQuestionResult

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
id	string	Ja

Svar

Returnerer: GetQuestionResultResponse

Eksempel

getQuestionResult Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
options	const GetQuestionResultsOptions&	Yes

Svar

Returnerer: GetQuestionResultsResponse

Eksempel

getQuestionResults Eksempel

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();
        // håndter svar
    });

updateQuestionResult

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
updateQuestionResultBody	UpdateQuestionResultBody	Ja

Svar

Returnerer: APIEmptyResponse

Eksempel

updateQuestionResult Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
options	const AggregateQuestionResultsOptions&	Yes

Svar

Returnerer: AggregateQuestionResultsResponse

Eksempel

aggregateQuestionResults Eksempel

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

Parametre

Name	Type	Required
tenantId	string	Ja
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Ja
forceRecalculate	bool	Nej

Svar

Returnerer: BulkAggregateQuestionResultsResponse

Eksempel

bulkAggregateQuestionResults Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const CombineCommentsWithQuestionResultsOptions&	Ja

Respons

Returnerer: CombineQuestionResultsWithCommentsResponse

Eksempel

combineCommentsWithQuestionResults Eksempel

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);
            // Brug den kombinerede efter behov
        }catch(const std::exception&){
        }
    });

addSSOUser

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
createAPISSOUserData	CreateAPISSOUserData	Yes

Svar

Returnerer: AddSSOUserAPIResponse

Eksempel

addSSOUser Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
options	const DeleteSSOUserOptions&	Ja

Svar

Returnerer: DeleteSSOUserAPIResponse

Eksempel

deleteSSOUser Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
email	string	Yes

Svar

Returnerer: GetSSOUserByEmailAPIResponse

Eksempel

getSSOUserByEmail Eksempel

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

Parametre

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Svar

Returnerer: GetSSOUserByIdAPIResponse

Eksempel

getSSOUserById Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
skip	int32_t	Nej

Svar

Returnerer: GetSSOUsersResponse

Eksempel

getSSOUsers Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
updateAPISSOUserData	UpdateAPISSOUserData	Ja
updateComments	bool	Nej

Svar

Returnerer: PatchSSOUserAPIResponse

Eksempel

patchSSOUser Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
updateAPISSOUserData	UpdateAPISSOUserData	Ja
updateComments	bool	Nej

Respons

Returnerer: PutSSOUserAPIResponse

Eksempel

putSSOUser Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Yes

Respons

Returnerer: CreateSubscriptionAPIResponse

Eksempel

createSubscription Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
userId	string	Nej

Svar

Returnerer: DeleteSubscriptionAPIResponse

Eksempel

deleteSubscription Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
userId	string	No

Respons

Returnerer: GetSubscriptionsAPIResponse

Eksempel

getSubscriptions Eksempel

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();
            // behandl svar
        } catch (const std::exception& e) {
            // håndter fejl
        }
    }
);

updateSubscription

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	Ja
userId	string	Nej

Svar

Returnerer: UpdateSubscriptionAPIResponse

Eksempel

updateSubscription Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const GetTenantDailyUsagesOptions&	Ja

Svar

Returnerer: GetTenantDailyUsagesResponse

Eksempel

getTenantDailyUsages Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
createTenantPackageBody	CreateTenantPackageBody	Yes

Svar

Returnerer: CreateTenantPackageResponse

Eksempel

createTenantPackage Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
id	string	Ja

Svar

Returns: APIEmptyResponse

Eksempel

deleteTenantPackage Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
id	string	Yes

Svar

Returnerer: GetTenantPackageResponse

Eksempel

getTenantPackage Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
skip	double	No

Respons

Returns: GetTenantPackagesResponse

Eksempel

getTenantPackages Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
replaceTenantPackageBody	ReplaceTenantPackageBody	Ja

Svar

Returnerer: APIEmptyResponse

Eksempel

replaceTenantPackage Eksempel

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

Parametre

Navn	Type	Krævet
tenantId	string	Yes
id	string	Yes
updateTenantPackageBody	UpdateTenantPackageBody	Yes

Svar

Returnerer: APIEmptyResponse

Eksempel

updateTenantPackage Eksempel

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();
            // håndtering af succes
        } catch (const std::exception& ex) {
            // håndtering af fejl
        }
    });

createTenantUser

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
createTenantUserBody	CreateTenantUserBody	Ja

Svar

Returnerer: CreateTenantUserResponse

Eksempel

createTenantUser Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
options	const DeleteTenantUserOptions&	Ja

Svar

Returnerer: APIEmptyResponse

Eksempel

deleteTenantUser Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
id	string	Ja

Respons

Returnerer: GetTenantUserResponse

Eksempel

getTenantUser Eksempel

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();
            // Brug svaret efter behov
        } catch (const std::exception&) {
            // Fejlhåndtering
        }
    });

getTenantUsers

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
skip	double	Nej

Svar

Returnerer: GetTenantUsersResponse

Eksempel

getTenantUsers Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
id	string	Yes
replaceTenantUserBody	ReplaceTenantUserBody	Yes
updateComments	string	No

Svar

Returnerer: APIEmptyResponse

Eksempel

replaceTenantUser Eksempel

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

Parametre

Navn	Type	Krævet
tenantId	string	Ja
id	string	Ja
redirectURL	string	Nej

Svar

Returnerer: APIEmptyResponse

Eksempel

sendLoginLink Eksempel

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

Parametre

Navn	Type	Krævet
tenantId	string	Yes
id	string	Yes
updateTenantUserBody	UpdateTenantUserBody	Yes
updateComments	string	No

Svar

Returnerer: APIEmptyResponse

Eksempel

updateTenantUser Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
createTenantBody	CreateTenantBody	Yes

Svar

Returnerer: CreateTenantResponse

Eksempel

createTenant Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
sure	string	Nej

Svar

Returnerer: APIEmptyResponse

Eksempel

deleteTenant Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
id	string	Yes

Svar

Returnerer: GetTenantResponse

Eksempel

getTenant Eksempel

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

Parametre

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

Svar

Returnerer: GetTenantsResponse

Eksempel

getTenants Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
updateTenantBody	UpdateTenantBody	Ja

Svar

Returnerer: APIEmptyResponse

Eksempel

updateTenant Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
userId	string	Ja
id	string	Ja
changeTicketStateBody	ChangeTicketStateBody	Ja

Svar

Returnerer: ChangeTicketStateResponse

Eksempel

changeTicketState Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
userId	string	Ja
createTicketBody	CreateTicketBody	Ja

Svar

Returnerer: CreateTicketResponse

Eksempel

createTicket Eksempel

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();
        // Brug svaret efter behov
    }catch(const std::exception&){
        // Håndter fejl
    }
});

getTicket

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
id	string	Yes
userId	string	No

Svar

Returnerer: GetTicketResponse

Eksempel

getTicket Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
options	const GetTicketsOptions&	Yes

Svar

Returnerer: GetTicketsResponse

Eksempel

getTickets Eksempel

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

Parametre

Navn	Type	Påkrævet
r_namespace	string	Yes
component	string	Yes
options	const GetTranslationsOptions&	Yes

Svar

Returnerer: GetTranslationsResponse

Eksempel

Eksempel på getTranslations

Copy

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

uploadImage

Upload og ændre størrelse på et billede

Parameters

Navn	Type	Påkrævet
tenantId	string	Ja
file	HttpContent	Ja
options	const UploadImageOptions&	Ja

Response

Returnerer: UploadImageResponse

Example

uploadImage Eksempel

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

Parametre

Navn	Type	Obligatorisk	Beskrivelse
tenantId	string	Ja
id	string	Ja

Svar

Returnerer: APIGetUserBadgeProgressResponse

Eksempel

getUserBadgeProgressById Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
userId	string	Yes

Svar

Returnerer: APIGetUserBadgeProgressResponse

Eksempel

getUserBadgeProgressByUserId Eksempel

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

Parametre

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

Svar

Returnerer: APIGetUserBadgeProgressListResponse

Eksempel

getUserBadgeProgressList Eksempel

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

createUserBadge

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
createUserBadgeParams	CreateUserBadgeParams	Ja

Respons

Returnerer: APICreateUserBadgeResponse

Eksempel

createUserBadge Eksempel

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

Parametre

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Svar

Returnerer: APIEmptySuccessResponse

Eksempel

deleteUserBadge Eksempel

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

Parametre

Navn	Type	Krævet	Beskrivelse
tenantId	string	Ja
id	string	Ja

Svar

Returnerer: APIGetUserBadgeResponse

Eksempel

getUserBadge Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const GetUserBadgesOptions&	Ja

Svar

Returnerer: APIGetUserBadgesResponse

Eksempel

getUserBadges Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
id	string	Yes
updateUserBadgeParams	UpdateUserBadgeParams	Yes

Svar

Returnerer: APIEmptySuccessResponse

Eksempel

updateUserBadge Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
sso	string	Nej

Svar

Returnerer: GetUserNotificationCountResponse

Eksempel

getUserNotificationCount Eksempel

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();
        // brug resp efter behov
    }catch(const std::exception&){
        // håndter fejl
    }
});

getUserNotifications

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
options	const GetUserNotificationsOptions&	Yes

Svar

Returnerer: GetMyNotificationsResponse

Eksempel

Eksempel på getUserNotifications

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
sso	string	Nej

Svar

Returnerer: ResetUserNotificationsResponse

Eksempel

resetUserNotificationCount Eksempel

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

Parameters

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
options	const ResetUserNotificationsOptions&	Ja

Response

Returnerer: ResetUserNotificationsResponse

Example

resetUserNotifications Eksempel

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

updateUserNotificationCommentSubscriptionStatus

Aktiver eller deaktiver meddelelser for en specifik kommentar.

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
notificationId	string	Yes
optedInOrOut	string	Yes
commentId	string	Yes
sso	string	No

Respons

Returns: UpdateUserNotificationCommentSubscriptionStatusResponse

Eksempel

updateUserNotificationCommentSubscriptionStatus Eksempel

Copy

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

updateUserNotificationPageSubscriptionStatus

Enable eller deaktiver meddelelser for en side. Når brugere er abonneret på en side, oprettes meddelelser for nye rodkommentarer, og også

Parameters

Navn	Type	Påkrævet
tenantId	string	Yes
urlId	string	Yes
url	string	Yes
pageTitle	string	Yes
subscribedOrUnsubscribed	string	Yes
sso	string	No

Response

Returnerer: UpdateUserNotificationPageSubscriptionStatusResponse

Example

updateUserNotificationPageSubscriptionStatus Eksempel

Copy

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

updateUserNotificationStatus

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
notificationId	string	Ja
newStatus	string	Ja
sso	string	Nej

Respons

Returnerer: UpdateUserNotificationStatusResponse

Eksempel

updateUserNotificationStatus Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
urlIdWS	string	Ja
userIds	string	Ja

Svar

Returnerer: GetUserPresenceStatusesResponse

Eksempel

getUserPresenceStatuses Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
urlId	string	Ja
options	const SearchUsersOptions&	Ja

Svar

Returnerer: SearchUsersResult

Eksempel

searchUsers Eksempel

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

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Ja
id	string	Ja

Svar

Returnerer: GetUserResponse

Eksempel

getUser Eksempel

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>();
            }
            // behandl svar efter behov
        } catch (const std::exception&) {
            // håndter fejl
        }
    });

createVote

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
commentId	string	Yes
direction	string	Yes
options	const CreateVoteOptions&	Yes

Svar

Returnerer: VoteResponse

Eksempel

createVote Eksempel

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

Parametre

Navn	Type	Påkrævet
tenantId	string	Ja
id	string	Ja
editKey	string	Nej

Svar

Returnerer: VoteDeleteResponse

Eksempel

deleteVote Eksempel

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();
        // Behandl svar efter behov
    } catch (const std::exception&) {
        // Håndter fejl
    }
});

getVotes

Parametre

Navn	Type	Påkrævet	Beskrivelse
tenantId	string	Yes
urlId	string	Yes

Respons

Returnerer: GetVotesResponse

Eksempel

getVotes Eksempel

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 (...) {
        // fejlhåndtering
    }
});

getVotesForUser

Parametre

Navn	Type	Påkrævet
tenantId	string	Yes
urlId	string	Yes
options	const GetVotesForUserOptions&	Yes

Svar

Returnerer: GetVotesForUserResponse

Eksempel

getVotesForUser Eksempel

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) {
        // handle response, e.g., iterate votes
    }
});

Brug for hjælp?

Hvis du oplever problemer eller har spørgsmål om C++ SDK, så:

Bidrag

Bidrag er velkomne! Besøg venligst GitHub-repositoriet for retningslinjer for bidrag.

Sprog 🇩🇰 Dansk

Dokumentation

Kom godt i gang

API-reference

Brug

Aggregering

Revisionslog

Autentificering

Bloker fra kommentar

Kontroller blokerede kommentarer

Kommentarer

Kommentarer for bruger

Domænekonfigurationer

E-mail-skabeloner

Hændelseslog

Feed-opslag

Marker kommentar

GIF'er

Hashtags

Moderering

Moderatorer

Antal notifikationer

Notifikationer

Side-reaktioner

Sider

Afventende webhook-hændelser

Spørgsmålskonfigurationer

Resultater for spørgsmål

Aggregering af spørgsmålresultater

SSO-brugere

Abonnementer

Lejers daglige forbrug

Lejerpakker

Lejerbrugere

Lejere

Supportbilletter

Oversættelser

Upload billede

Brugerbadge-fremgang

Brugerbadges

Brugernotifikationer

Brugertilstedeværelsesstatus

Brugersøgning

Brugere

Stemmer

FastComments C++ SDK

Repository

Krav

Installation

Installer afhængigheder

Byg fra kildekode

Installation

Biblioteksindhold

Offentlige vs sikrede API'er

Hurtigstart

Brug af autentificerede API'er (DefaultAPI)

Brug af offentlige API'er (PublicAPI)

Brug af moderations‑API'er (ModerationApi)

Almindelige problemer

Foretage API-opkald: Synkront vs Asynkront

Synkrone kald med .get()

Asynkrone kald med .then()

Valg mellem synkron og asynkron

Noter

Broadcast-id'er

SSO (Single Sign-On)

Brug af SSO

Simpel SSO

Sikker SSO

Dokumentation for fastcomments

Dokumentation for API-endpunkter

Dokumentation for modeller

aggregate

Parameters

Response

Example

getAuditLogs

Parametre

Svar

Eksempel

Synkrone kald med `.get()`

Asynkrone kald med `.then()`