FastComments C++ SDK

이것은 FastComments의 공식 C++ SDK입니다.

FastComments API용 공식 C++ SDK

리포지토리

AI 코딩 에이전트

코딩 에이전트에게 FastComments 컨텍스트가 필요합니다 - 위젯, 구성, Secure SSO, REST API 및 SDK:

npx skills add fastcomments/skills

Claude Code, Codex, Cursor, Copilot, Gemini 및 모든 다른 에이전트와 함께 작동하며, skills CLI 가 지원합니다.

요구 사항

C++17 이상
CMake 3.14 이상
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (테스트를 위해 자동으로 다운로드됨)

설치

의존성 설치

sudo apt install libcpprest-dev libboost-all-dev

소스에서 빌드하기

mkdir build
cd build
cmake ..
make

설치하기

sudo make install

라이브러리 구성

이 라이브러리는 생성된 API 클라이언트와 API 작업을 더 쉽게 만들어 주는 SSO 유틸리티를 포함하고 있습니다.

API 클라이언트 라이브러리 문서

공개 API vs 보안 API

API 클라이언트에는 DefaultApi, PublicApi, ModerationApi 세 가지 클래스가 있습니다. DefaultApi는 API 키가 필요한 메서드를 포함하며, PublicApi는 인증 없이 브라우저/모바일 기기 등에서 직접 호출할 수 있는 메서드를 포함합니다. ModerationApi는 실시간 빠른 검토(모더레이션)를 위한 폭넓은 API 모음을 제공합니다. 모든 ModerationApi 메서드는 sso 매개변수를 받으며, SSO 또는 FastComments.com 세션 쿠키를 통해 인증할 수 있습니다.

빠른 시작

인증 API 사용하기 (DefaultAPI)

중요:

기본 URL을 설정해야 합니다 (cpp-restsdk 생성기는 OpenAPI 사양에서 이를 읽지 않습니다)
인증이 필요한 요청을 보내기 전에 ApiClient에 API 키를 설정해야 합니다. 그렇지 않으면 요청이 401 오류로 실패합니다.

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

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

    // 필수: 기본 URL 설정 (지역 선택)
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));  // US
    // 또는: config->setBaseUrl(utility::conversions::to_string_t("https://eu.fastcomments.com"));  // EU

    // 필수: API 키 설정
    config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_API_KEY_HERE"));

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

    // 이제 인증된 API 호출을 수행합니다
    return 0;
}

퍼블릭 API 사용하기 (PublicAPI)

퍼블릭 엔드포인트는 인증이 필요하지 않습니다:

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

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

    // 필수: 기본 URL 설정
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

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

    // 퍼블릭 API 호출 수행
    return 0;
}

모더레이션 API 사용하기 (ModerationApi)

ModerationApi는 모더레이터 대시보드를 구동합니다. 모든 메서드는 sso 매개변수를 받아들이므로, SSO로 인증된 모더레이터를 대신하여 호출이 실행됩니다(토큰 생성 방법은 아래 SSO 섹션을 참조하세요):

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

    // 필수: 기본 URL 설정
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

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

    // 호출을 인증하기 위해 모더레이터의 SSO 토큰을 전달합니다
    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;
}

일반적인 문제

"URI must contain a hostname" 오류: ApiClient를 생성하기 전에 config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"))을 호출했는지 확인하세요. cpp-restsdk 생성기는 OpenAPI 사양에서 서버 URL을 자동으로 읽지 않습니다.
401 "missing-api-key" 오류: DefaultAPI 인스턴스를 생성하기 전에 config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY"))를 호출했는지 확인하세요.
잘못된 API 클래스 사용: 서버 측 인증 요청에는 DefaultApi를, 클라이언트 측/퍼블릭 요청에는 PublicApi를, 모더레이터 대시보드 요청(모더레이터 SSO 토큰으로 인증)에는 ModerationApi를 사용하세요.

API 호출 만들기: 동기 vs 비동기

이 SDK의 모든 API 메서드는 C++ REST SDK의 pplx::task<std::shared_ptr<ResponseType>>를 반환합니다. 이를 통해 API 응답을 유연하게 처리할 수 있습니다.

`.get()`을 사용한 동기 호출

.get()을 사용하면 요청이 완료될 때까지 호출 스레드를 차단하고 결과를 동기적으로 가져올 수 있습니다:

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

// 필수 매개변수는 위치 인자로 전달하고, 선택적 매개변수는 options 구조체에 넣습니다
org::openapitools::client::api::GetCommentsOptions options;
options.urlId = utility::conversions::to_string_t("your-url-id");

// .get()을 호출하여 차단하고 결과를 동기적으로 가져옵니다
auto response = api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    options
).get();  // HTTP 요청이 완료될 때까지 차단합니다

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

`.then()`을 사용한 비동기 호출

.then()을 사용하면 콜백 기반의 논블로킹 비동기 실행이 가능합니다:

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

// 필수 매개변수는 위치 인자로 전달하고, 선택적 매개변수는 options 구조체에 넣습니다
org::openapitools::client::api::GetCommentsOptions options;
options.urlId = utility::conversions::to_string_t("your-url-id");

// 비동기 콜백 기반 실행을 위해 .then()을 사용합니다
api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    options
).then([](std::shared_ptr<GetComments_200_response> response) {
    // 요청이 완료되면 비동기적으로 실행됩니다
    if (response && response->comments) {
        std::cout << "Found " << response->comments->size() << " comments" << std::endl;
    }
});

// 차단 없이 즉시 실행이 계속됩니다
std::cout << "Request sent, continuing..." << std::endl;

동기식과 비동기식 중 선택하기

선택은 런타임 환경과 애플리케이션 아키텍처에 따라 달라집니다:

.get() (동기 블로킹)

HTTP 요청이 완료될 때까지 호출 스레드를 차단합니다
코드 흐름이 단순하고 이해하기 쉽습니다
전용 워커 스레드, 배치 처리, 명령줄 도구에 적합합니다
이벤트 루프, GUI 스레드, 단일 스레드 서버에는 적합하지 않습니다

.then() (비동기 논블로킹)

즉시 반환되며, 요청이 완료되면 콜백이 실행됩니다
호출 스레드를 차단하지 않습니다
이벤트 기반 아키텍처, GUI 애플리케이션, 단일 스레드 이벤트 루프에 필수적입니다
여러 작업을 체이닝할 수 있습니다
제어 흐름이 더 복잡합니다

SDK의 테스트 스위트는 .get()만 사용하지만, 이는 블로킹이 허용되는 테스트 환경에서는 적절합니다.

노트

브로드캐스트 ID

일부 API 호출에서 broadcastId를 전달해야 한다는 것을 보게 될 것입니다. 이벤트를 수신하면 이 ID가 다시 반환되므로, 클라이언트에서 낙관적으로 변경을 적용하려는 경우 해당 이벤트를 무시해야 하는지 알 수 있습니다 (대부분 그렇게 하는 것이 가장 좋은 사용자 경험을 제공하므로 아마 그렇게 하게 될 것입니다). 여기에는 UUID를 전달하세요. 이 ID는 브라우저 세션에서 두 번 발생하지 않을 만큼 충분히 고유해야 합니다.

SSO (싱글 사인온)

SSO 예제는 아래를 참조하세요.

SSO 사용

간단한 SSO

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

using namespace fastcomments::sso;

int main() {
    SimpleSSOUserData user("user-123", "user@example.com", "https://example.com/avatar.jpg");
    FastCommentsSSO sso = FastCommentsSSO::newSimple(user);
    std::string token = sso.createToken();

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

보안 SSO

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

using namespace fastcomments::sso;

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

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

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

fastcomments 문서

Documentation for API Endpoints

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

Class	Method	HTTP request	Description
DefaultApi	addDomainConfig	POST /api/v1/domain-configs
DefaultApi	addHashTag	POST /api/v1/hash-tags
DefaultApi	addHashTagsBulk	POST /api/v1/hash-tags/bulk
DefaultApi	addPage	POST /api/v1/pages
DefaultApi	addSSOUser	POST /api/v1/sso-users
DefaultApi	aggregate	POST /api/v1/aggregate	Aggregates documents by grouping them (if groupBy is provided) and applying multiple operations. Different operations (e.g. sum, countDistinct, avg, etc.) are supported.
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	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.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	Currently-online viewers of a page: people whose websocket session is subscribed to the page right now. Returns anonCount + totalCount (room-wide subscribers, including anon viewers we don't enumerate).
PublicApi	getPagesPublic	GET /pages/{tenantId}	List pages for a tenant. Used by the FChat desktop client to populate its room list. Requires `enableFChat` to be true on the resolved custom config for each page. Pages that require SSO are filtered against the requesting user's group access.
PublicApi	getTranslations	GET /translations/{namespace}/{component}
PublicApi	getUserNotificationCount	GET /user-notifications/get-count
PublicApi	getUserNotifications	GET /user-notifications
PublicApi	getUserPresenceStatuses	GET /user-presence-status
PublicApi	getUserReactsPublic	GET /feed-posts/{tenantId}/user-reacts
PublicApi	getUsersInfo	GET /pages/{tenantId}/users/info	Bulk user info for a tenant. Given userIds, return display info from User / SSOUser. Used by the comment widget to enrich users that just appeared via a presence event. No page context: privacy is enforced uniformly (private profiles are masked).
PublicApi	getV1PageLikes	GET /page-reacts/v1/likes/{tenantId}
PublicApi	getV2PageReactUsers	GET /page-reacts/v2/{tenantId}/list
PublicApi	getV2PageReacts	GET /page-reacts/v2/{tenantId}
PublicApi	lockComment	POST /comments/{tenantId}/{commentId}/lock
PublicApi	logoutPublic	PUT /auth/logout
PublicApi	pinComment	POST /comments/{tenantId}/{commentId}/pin
PublicApi	reactFeedPostPublic	POST /feed-posts/{tenantId}/react/{postId}
PublicApi	resetUserNotificationCount	POST /user-notifications/reset-count
PublicApi	resetUserNotifications	POST /user-notifications/reset
PublicApi	searchUsers	GET /user-search/{tenantId}
PublicApi	setCommentText	POST /comments/{tenantId}/{commentId}/update-text
PublicApi	unBlockCommentPublic	DELETE /block-from-comment/{commentId}
PublicApi	unLockComment	POST /comments/{tenantId}/{commentId}/unlock
PublicApi	unPinComment	POST /comments/{tenantId}/{commentId}/unpin
PublicApi	updateFeedPostPublic	PUT /feed-posts/{tenantId}/{postId}
PublicApi	updateUserNotificationCommentSubscriptionStatus	POST /user-notifications/{notificationId}/mark-opted/{optedInOrOut}	Enable or disable notifications for a specific comment.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Enable or disable notifications for a page. When users are subscribed to a page, notifications are created for new root comments, and also
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Upload and resize an image
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Documentation for Models

Documentation for Authorization

api_key

Type: API key
API key parameter name: x-api-key
Location: HTTP header

집계

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

Parameters

이름	유형	필수
tenantId	string	Yes
aggregationRequest	AggregationRequest	Yes
options	const AggregateOptions&	Yes

Response

반환: AggregateResponse

Example

aggregate 예제

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();
            // 응답 처리
        } catch (const std::exception& e) {
            // 오류 처리
        }
    });

감사 로그 가져오기

매개변수

Name	Type	Required	Description
tenantId	string	예
options	const GetAuditLogsOptions&	예

응답

반환: GetAuditLogsResponse

예시

getAuditLogs 예시

Copy

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

공개 로그아웃

응답

반환: APIEmptyResponse

예시

logoutPublic 예시

Copy

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

공개 댓글 차단

매개변수

이름	타입	필수
tenantId	string	예
commentId	string	예
publicBlockFromCommentParams	PublicBlockFromCommentParams	예
sso	string	아니오

응답

반환: BlockSuccess

예제

blockFromCommentPublic 예제

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

공개 댓글 차단 해제

매개변수

이름	유형	필수
tenantId	string	Yes
commentId	string	Yes
publicBlockFromCommentParams	PublicBlockFromCommentParams	Yes
sso	string	No

응답

반환: UnblockSuccess

예제

unBlockCommentPublic 예제

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

차단된 댓글 확인

매개변수

이름	형식	필수
tenantId	string	Yes
commentIds	string	Yes
sso	string	No

응답

반환: CheckBlockedCommentsResponse

예시

checkedCommentsForBlocked 예제

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

댓글에서 사용자 차단

매개변수

이름	유형	필수
tenantId	string	예
id	string	예
blockFromCommentParams	BlockFromCommentParams	예
options	const BlockUserFromCommentOptions&	예

응답

반환: BlockSuccess

예시

blockUserFromComment 예제

Copy

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

공개 댓글 생성

매개변수

이름	유형	필수
tenantId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
commentData	CommentData	Yes
options	const CreateCommentPublicOptions&	Yes

응답

Returns: SaveCommentsResponseWithPresence

예제

createCommentPublic 예제

Copy

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

댓글 삭제

매개변수

이름	유형	필수
tenantId	string	예
id	string	예
options	const DeleteCommentOptions&	예

응답

반환: DeleteCommentResult

예시

deleteComment 예제

Copy

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

공개 댓글 삭제

매개변수

이름	유형	필수
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
options	const DeleteCommentPublicOptions&	Yes

응답

반환: PublicAPIDeleteCommentResponse

예시

deleteCommentPublic 예제

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

댓글 투표 삭제

매개변수

이름	유형	필수
tenantId	string	Yes
commentId	string	Yes
voteId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
options	const DeleteCommentVoteOptions&	Yes

응답

Returns: VoteDeleteResponse

예제

deleteCommentVote 예제

Copy

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

댓글 신고

매개변수

이름	유형	필수
tenantId	string	예
id	string	예
options	const FlagCommentOptions&	예

응답

반환: FlagCommentResponse

예제

flagComment 예제

Copy

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

댓글 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	예
id	string	예

응답

Returns: APIGetCommentResponse

예시

getComment 예시

Copy

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

댓글 목록 가져오기

Parameters

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

Response

반환: APIGetCommentsResponse

Example

getComments 예제

Copy

utility::string_t tenantId = U("my-tenant-123");
GetCommentsOptions options;
options.page = 1;
options.limit = 50;
options.sort = U("newest");
options.authorEmail = boost::optional<utility::string_t>(U("user@example.com"));
api->getComments(tenantId, options).then([](pplx::task<std::shared_ptr<APIGetCommentsResponse>> task) {
    try {
        auto response = task.get();
        // 필요에 따라 응답 사용
    } catch (const std::exception& e) {
        // 오류 처리
    }
});

공개 댓글 목록 가져오기

req tenantId urlId

매개변수

Name	Type	Required
tenantId	string	예
urlId	string	예
options	const GetCommentsPublicOptions&	예

응답

Returns: GetCommentsResponseWithPresence_PublicComment_

예시

getCommentsPublic 예시

Copy

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

댓글 텍스트 가져오기

매개변수

이름	유형	필수
tenantId	string	예
commentId	string	예
options	const GetCommentTextOptions&	예

응답

반환: PublicAPIGetCommentTextResponse

예시

getCommentText 예시

Copy

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

댓글 투표 사용자 이름 가져오기

매개변수

이름	유형	필수
tenantId	string	Yes
commentId	string	Yes
dir	int32_t	Yes
sso	string	No

응답

반환: GetCommentVoteUserNamesSuccessResponse

예제

getCommentVoteUserNames 예제

Copy

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

댓글 잠금

매개변수

이름	형식	필수
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

응답

반환: APIEmptyResponse

예시

lockComment 예시

Copy

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

댓글 고정

매개변수

이름	유형	필수
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

응답

반환: ChangeCommentPinStatusResponse

예제

pinComment 예제

Copy

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

댓글 저장

Parameters

이름	타입	필수
tenantId	string	예
createCommentParams	CreateCommentParams	예
options	const SaveCommentOptions&	예

응답

반환: APISaveCommentResponse

예제

saveComment 예제

Copy

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

댓글 텍스트 설정

매개변수

이름	형식	필수
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
commentTextUpdateRequest	CommentTextUpdateRequest	Yes
options	const SetCommentTextOptions&	Yes

응답

반환: PublicAPISetCommentTextResponse

예시

setCommentText 예시

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

댓글에서 사용자 차단 해제

매개변수

이름	유형	필수
tenantId	string	예
id	string	예
unBlockFromCommentParams	UnBlockFromCommentParams	예
options	const UnBlockUserFromCommentOptions&	예

응답

반환: UnblockSuccess

예제

unBlockUserFromComment 예제

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

댓글 신고 해제

매개변수

Name	Type	Required
tenantId	string	Yes
id	string	Yes
options	const UnFlagCommentOptions&	Yes

응답

반환: FlagCommentResponse

예시

unFlagComment 예시

Copy

auto options = UnFlagCommentOptions{};
options.reason = boost::optional<utility::string_t>(U("Resolved by moderator"));
api->unFlagComment(U("my-tenant-123"), U("comment-456"), options)
    .then([](std::shared_ptr<FlagCommentResponse> response) {
        if (response) {
            auto status = response->status;
            // 필요에 따라 상태를 처리합니다
        }
    })
    .then([](pplx::task<void> previous) {
        try {
            previous.get();
        } catch (const std::exception& e) {
            // 오류를 처리합니다
        }
    });

댓글 잠금 해제

Parameters

이름	타입	필수
tenantId	string	예
commentId	string	예
broadcastId	string	예
sso	string	아니오

Response

반환: APIEmptyResponse

Example

unLockComment 예제

Copy

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

댓글 고정 해제

매개변수

이름	유형	필수
tenantId	string	예
commentId	string	예
broadcastId	string	예
sso	string	아니오

응답

반환: ChangeCommentPinStatusResponse

예시

unPinComment 예제

Copy

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

댓글 업데이트

Parameters

이름	유형	필수
tenantId	string	예
id	string	예
updatableCommentParams	UpdatableCommentParams	예
options	const UpdateCommentOptions&	예

Response

반환: APIEmptyResponse

예시

updateComment 예제

Copy

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

댓글 투표

매개변수

이름	타입	필수
tenantId	string	예
commentId	string	예
urlId	string	예
broadcastId	string	예
voteBodyParams	VoteBodyParams	예
options	const VoteCommentOptions&	예

응답

반환: VoteResponse

예제

voteComment 예제

Copy

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

사용자 댓글 가져오기

매개변수

이름	형식	필수	설명
options	const GetCommentsForUserOptions&	예

응답

반환: GetCommentsForUserResponse

예제

getCommentsForUser 예제

Copy

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

도메인 설정 추가

파라미터

이름	형식	필수	설명
tenantId	string	예
addDomainConfigParams	AddDomainConfigParams	예

응답

Returns: AddDomainConfigResponse

예시

addDomainConfig 예시

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

도메인 설정 삭제

매개변수

이름	유형	필수	설명
tenantId	string	Yes
domain	string	Yes

응답

반환: DeleteDomainConfigResponse

예제

deleteDomainConfig 예제

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

도메인 설정 가져오기

매개변수

이름	형식	필수	설명
tenantId	string	예
domain	string	예

응답

반환: GetDomainConfigResponse

예시

getDomainConfig 예시

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domain = U("myblog.example.com");
api->getDomainConfig(tenantId, domain)
    .then([](std::shared_ptr<GetDomainConfigResponse> response) {
        if (!response) return;
        boost::optional<bool> moderationEnabled = response->moderationEnabled;
        boost::optional<std::string> theme = response->theme;
        if (moderationEnabled && *moderationEnabled) {
            // 활성화된 모더레이션 처리
        }
        if (theme) {
            // 테마 값을 사용
        }
    })
    .wait();

도메인 설정 목록 가져오기

Parameters

이름	형식	필수	설명
tenantId	string	예

Response

반환: GetDomainConfigsResponse

Example

getDomainConfigs 예제

Copy

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

도메인 설정 패치

Parameters

이름	타입	필수
tenantId	string	Yes
domainToUpdate	string	Yes
patchDomainConfigParams	PatchDomainConfigParams	Yes

Response

Returns: PatchDomainConfigResponse

예시

patchDomainConfig 예시

Copy

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

도메인 설정 저장

매개변수

이름	유형	필수
tenantId	string	Yes
domainToUpdate	string	Yes
updateDomainConfigParams	UpdateDomainConfigParams	Yes

응답

반환: PutDomainConfigResponse

예시

putDomainConfig 예시

Copy

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

이메일 템플릿 생성

매개변수

이름	유형	필수	설명
tenantId	string	Yes
createEmailTemplateBody	CreateEmailTemplateBody	Yes

응답

반환: CreateEmailTemplateResponse

예시

createEmailTemplate 예시

Copy

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

이메일 템플릿 삭제

매개변수

이름	유형	필수	설명
tenantId	string	예
id	string	예

응답

반환: APIEmptyResponse

예시

deleteEmailTemplate 예제

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

이메일 템플릿 렌더링 오류 삭제

매개변수

이름	유형	필수
tenantId	string	예
id	string	예
errorId	string	예

응답

반환: APIEmptyResponse

예시

deleteEmailTemplateRenderError 예제

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

이메일 템플릿 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	Yes
id	string	Yes

응답

반환: GetEmailTemplateResponse

예제

getEmailTemplate 예제

Copy

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

이메일 템플릿 정의 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	Yes

응답

반환: GetEmailTemplateDefinitionsResponse

예시

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

이메일 템플릿 렌더링 오류 가져오기

매개변수

이름	유형	필수
tenantId	string	예
id	string	예
skip	double	아니오

응답

반환: GetEmailTemplateRenderErrorsResponse

예시

getEmailTemplateRenderErrors 예제

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("email-template-789");
boost::optional<double> skip = 20.0;
api->getEmailTemplateRenderErrors(tenantId, id, skip)
    .then([](pplx::task<std::shared_ptr<GetEmailTemplateRenderErrorsResponse>> task) {
        try {
            auto response = task.get();
            // 필요에 따라 응답 사용
        } catch (const std::exception& ex) {
            // 오류 처리
        }
    });

이메일 템플릿 목록 가져오기

매개변수

이름	형식	필수	설명
tenantId	string	Yes
skip	double	No

응답

반환: GetEmailTemplatesResponse

예시

getEmailTemplates 예시

Copy

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

이메일 템플릿 렌더링

매개변수

이름	유형	필수
tenantId	string	예
renderEmailTemplateBody	RenderEmailTemplateBody	예
locale	string	아니오

응답

반환: RenderEmailTemplateResponse

예시

renderEmailTemplate 예시

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

이메일 템플릿 업데이트

매개변수

이름	유형	필수
tenantId	string	Yes
id	string	Yes
updateEmailTemplateBody	UpdateEmailTemplateBody	Yes

응답

반환: APIEmptyResponse

예시

updateEmailTemplate 예시

Copy

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

이벤트 로그 가져오기

req tenantId urlId userIdWS

매개변수

Name	Type	Required
tenantId	string	예
urlId	string	예
userIdWS	string	예
startTime	int64_t	예
endTime	int64_t	아니오

응답

반환: GetEventLogResponse

예시

getEventLog 예제

Copy

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

전체 이벤트 로그 가져오기

req
tenantId
urlId
userIdWS

매개변수

이름	유형	필수
tenantId	string	예
urlId	string	예
userIdWS	string	예
startTime	int64_t	예
endTime	int64_t	아니오

응답

반환: GetEventLogResponse

예제

getGlobalEventLog 예제

Copy

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

피드 포스트 생성

매개변수

이름	유형	필수
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
options	const CreateFeedPostOptions&	Yes

응답

Returns: CreateFeedPostsResponse

예시

createFeedPost 예제

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

공개 피드 포스트 생성

매개변수

이름	유형	필수
tenantId	string	예
createFeedPostParams	CreateFeedPostParams	예
options	const CreateFeedPostPublicOptions&	예

응답

반환: CreateFeedPostResponse

예제

createFeedPostPublic 예제

Copy

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

공개 피드 포스트 삭제

매개변수

이름	유형	필수
tenantId	string	Yes
postId	string	Yes
options	const DeleteFeedPostPublicOptions&	Yes

응답

반환: DeleteFeedPostPublicResponse

예시

deleteFeedPostPublic 예제

Copy

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

피드 포스트 가져오기

req tenantId afterId

매개변수

이름	형식	필수	설명
tenantId	string	예
options	const GetFeedPostsOptions&	예

응답

반환: GetFeedPostsResponse

예시

getFeedPosts 예시

Copy

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

공개 피드 포스트 가져오기

req tenantId afterId

매개변수

이름	유형	필수	설명
tenantId	string	예
options	const GetFeedPostsPublicOptions&	예

응답

반환: PublicFeedPostsResponse

예시

getFeedPostsPublic 예시

Copy

auto options = GetFeedPostsPublicOptions{};
options.limit = boost::optional<int>{20};
options.before = boost::optional<utility::string_t>{U("2023-01-01T00:00:00Z")};
api->getFeedPostsPublic(U("my-tenant-123"), options).then([](pplx::task<std::shared_ptr<PublicFeedPostsResponse>> task){
    try{
        auto response = task.get();
        auto processed = std::make_shared<PublicFeedPostsResponse>(*response);
        // 필요한 경우 processed 사용
    }catch(const std::exception&){
        // 오류 처리
    }
});

피드 포스트 통계 가져오기

매개변수

이름	유형	필수
tenantId	string	예
postIds	vector<string	예
sso	string	아니오

응답

반환: FeedPostsStatsResponse

예제

getFeedPostsStats 예시

Copy

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

공개 사용자 반응 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	Yes
options	const GetUserReactsPublicOptions&	Yes

응답

반환: UserReactsResponse

예시

getUserReactsPublic 예제

Copy

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

공개 피드 포스트에 반응

매개변수

이름	유형	필수
tenantId	string	Yes
postId	string	Yes
reactBodyParams	ReactBodyParams	Yes
options	const ReactFeedPostPublicOptions&	Yes

응답

반환: ReactFeedPostResponse

예제

reactFeedPostPublic 예제

Copy

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

피드 포스트 업데이트

매개변수

Name	Type	Required
tenantId	string	Yes
id	string	Yes
feedPost	FeedPost	Yes

응답

반환: APIEmptyResponse

예시

updateFeedPost 예제

Copy

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

공개 피드 포스트 업데이트

매개변수

이름	유형	필수
tenantId	string	예
postId	string	예
updateFeedPostParams	UpdateFeedPostParams	예
options	const UpdateFeedPostPublicOptions&	예

응답

반환: CreateFeedPostResponse

예시

updateFeedPostPublic 예시

Copy

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

공개 댓글 신고

매개변수

이름	유형	필수
tenantId	string	Yes
commentId	string	Yes
isFlagged	bool	Yes
sso	string	No

응답

반환: APIEmptyResponse

예시

flagCommentPublic 예시

Copy

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

큰 GIF 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	예
largeInternalURLSanitized	string	예

응답

반환: GifGetLargeResponse

예제

getGifLarge 예제

Copy

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

GIF 검색 가져오기

매개변수

Name	Type	Required
tenantId	string	예
search	string	예
options	const GetGifsSearchOptions&	예

응답

반환: GetGifsSearchResponse

예시

getGifsSearch 예시

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

트렌딩 GIF 가져오기

매개변수

이름	형식	필수	설명
tenantId	string	Yes
options	const GetGifsTrendingOptions&	Yes

응답

반환: GetGifsTrendingResponse

예시

getGifsTrending 예시

Copy

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

해시태그 추가

매개변수

이름	유형	필수	설명
tenantId	string	예
createHashTagBody	CreateHashTagBody	예

응답

반환: CreateHashTagResponse

예시

addHashTag 예시

Copy

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

해시태그 대량 추가

매개변수

이름	타입	필수	설명
tenantId	string	Yes
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Yes

응답

Returns: BulkCreateHashTagsResponse

예제

addHashTagsBulk 예제

Copy

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

해시태그 삭제

매개변수

이름	유형	필수
tenantId	string	Yes
tag	string	Yes
deleteHashTagRequestBody	DeleteHashTagRequestBody	Yes

응답

Returns: APIEmptyResponse

예시

deleteHashTag 예시

Copy

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

해시태그 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	Yes
page	double	No

응답

반환: GetHashTagsResponse

예제

getHashTags 예제

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
boost::optional<double> page = 2.0;
api->getHashTags(tenantId, page).then([](pplx::task<std::shared_ptr<GetHashTagsResponse>> task) {
    try {
        auto resultPtr = task.get();
        auto response = std::make_shared<GetHashTagsResponse>(*resultPtr);
        // 응답 사용
    } catch (const std::exception&) {
        // 오류 처리
    }
});

해시태그 패치

매개변수

이름	유형	필수
tenantId	string	예
tag	string	예
updateHashTagBody	UpdateHashTagBody	예

응답

반환: UpdateHashTagResponse

예제

patchHashTag 예제

Copy

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

중재 투표 삭제

매개변수

이름	유형	필수
tenantId	string	Yes
commentId	string	Yes
voteId	string	Yes
options	const DeleteModerationVoteOptions&	Yes

응답

반환: VoteDeleteResponse

예시

deleteModerationVote 예시

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

API 댓글 가져오기

매개변수

이름	형식	필수	설명
tenantId	string	예
options	const GetApiCommentsOptions&	예

응답

반환: ModerationAPIGetCommentsResponse

예제

getApiComments 예제

Copy

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

API 내보내기 상태 가져오기

매개변수

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

응답

Returns: ModerationExportStatusResponse

예시

getApiExportStatus 예시

Copy

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

API ID 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	Yes
options	const GetApiIdsOptions&	Yes

응답

Returns: ModerationAPIGetCommentIdsResponse

예제

getApiIds 예제

Copy

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

댓글에서 차단된 사용자 가져오기

매개변수

이름	유형	필수
tenantId	string	예
commentId	string	예
sso	string	아니오

응답

반환: GetBannedUsersFromCommentResponse

예제

getBanUsersFromComment 예제

Copy

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

댓글 차단 상태 가져오기

매개변수

이름	유형	필수
tenantId	string	Yes
commentId	string	Yes
sso	string	No

응답

반환: GetCommentBanStatusResponse

예시

getCommentBanStatus 예시

Copy

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

댓글 하위 댓글 가져오기

매개변수

이름	형식	필수
tenantId	string	예
commentId	string	예
sso	string	아니오

응답

반환: ModerationAPIChildCommentsResponse

예시

getCommentChildren 예제

Copy

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

카운트 가져오기

Parameters

이름	유형	필수	설명
tenantId	string	예
options	const GetCountOptions&	예

Response

반환: ModerationAPICountCommentsResponse

Example

getCount 예제

Copy

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

카운트들 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	Yes
sso	string	No

응답

반환: GetBannedUsersCountResponse

예제

getCounts 예제

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

로그 가져오기

매개변수

이름	유형	필수
tenantId	string	Yes
commentId	string	Yes
sso	string	No

응답

반환: ModerationAPIGetLogsResponse

예시

getLogs 예제

Copy

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

수동 배지 가져오기

매개변수

Name	Type	Required	Description
tenantId	string	Yes
sso	string	No

응답

Returns: GetTenantManualBadgesResponse

Example

getManualBadges 예제

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> sso = boost::make_optional(U("user@example.com"));
api->getManualBadges(tenantId, sso)
    .then([](pplx::task<std::shared_ptr<GetTenantManualBadgesResponse>> t) {
        try {
            auto response = t.get();
            // 응답을 처리, 예: response->badgeList
        } catch (const std::exception& ex) {
            // 오류 처리
        }
    });

사용자 수동 배지 가져오기

매개변수

이름	형식	필수	설명
tenantId	string	Yes
options	const GetManualBadgesForUserOptions&	Yes

응답

반환: GetUserManualBadgesResponse

예시

getManualBadgesForUser 예시

Copy

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

중재 댓글 가져오기

매개변수

이름	유형	필수
tenantId	string	Yes
commentId	string	Yes
options	const GetModerationCommentOptions&	Yes

응답

반환: ModerationAPICommentResponse

예시

getModerationComment 예시

Copy

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

중재 댓글 텍스트 가져오기

매개변수

이름	형식	필수
tenantId	string	Yes
commentId	string	Yes
sso	string	No

응답

반환: GetCommentTextResponse

예시

getModerationCommentText 예제

Copy

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

사전 차단 요약 가져오기

매개변수

이름	유형	필수
tenantId	string	Yes
commentId	string	Yes
options	const GetPreBanSummaryOptions&	Yes

응답

반환: PreBanSummary

예제

getPreBanSummary 예제

Copy

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

댓글 검색 요약 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	Yes
options	const GetSearchCommentsSummaryOptions&	Yes

응답

Returns: ModerationCommentSearchResponse

예시

getSearchCommentsSummary 예제

Copy

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

페이지 검색 가져오기

매개변수

이름	형식	필수	설명
tenantId	string	예
options	const GetSearchPagesOptions&	예

응답

반환: ModerationPageSearchResponse

예시

getSearchPages 예시

Copy

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

사이트 검색 가져오기

매개변수

이름	타입	필수	설명
tenantId	string	예
options	const GetSearchSitesOptions&	예

응답

반환: ModerationSiteSearchResponse

예제

getSearchSites 예제

Copy

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

검색 제안 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	예
options	const GetSearchSuggestOptions&	예

응답

반환: ModerationSuggestResponse

예제

getSearchSuggest 예제

Copy

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

사용자 검색 가져오기

매개변수

이름	형식	필수	설명
tenantId	string	예
options	const GetSearchUsersOptions&	예

응답

반환: ModerationUserSearchResponse

예시

getSearchUsers 예시

Copy

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

신뢰 요소 가져오기

매개변수

Name	Type	Required	Description
tenantId	string	예
options	const GetTrustFactorOptions&	예

응답

반환: GetUserTrustFactorResponse

예시

getTrustFactor 예제

Copy

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

사용자 차단 선호도 가져오기

매개변수

이름	형식	필수	설명
tenantId	string	예
sso	string	아니오

응답

반환: APIModerateGetUserBanPreferencesResponse

예제

getUserBanPreference 예제

Copy

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

사용자 내부 프로필 가져오기

Parameters

이름	유형	필수	설명
tenantId	string	Yes
options	const GetUserInternalProfileOptions&	Yes

Response

반환: GetUserInternalProfileResponse

Example

getUserInternalProfile 예시

Copy

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

댓글 투표 조정

매개변수

이름	유형	필수
tenantId	string	예
commentId	string	예
adjustCommentVotesParams	AdjustCommentVotesParams	예
options	const PostAdjustCommentVotesOptions&	예

응답

반환: AdjustVotesResponse

예시

postAdjustCommentVotes 예시

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

API 내보내기 요청

매개변수

이름	유형	필수	설명
tenantId	string	Yes
options	const PostApiExportOptions&	Yes

응답

반환: ModerationExportResponse

예시

postApiExport 예제

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) {
            // 성공적인 내보내기 응답 처리
        }
    })
    .wait();

댓글에서 사용자 차단

매개변수

이름	유형	필수
tenantId	string	Yes
commentId	string	Yes
options	const PostBanUserFromCommentOptions&	Yes

응답

반환: BanUserFromCommentResult

예제

postBanUserFromComment 예제

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) {
        // 결과 처리
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* 오류 처리 */ }
    });

사용자 차단 취소

매개변수

이름	형식	필수
tenantId	string	예
banUserUndoParams	BanUserUndoParams	예
sso	string	아니오

응답

반환: APIEmptyResponse

예시

postBanUserUndo 예시

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){
    // 성공 처리
});

대량 사전 차단 요약

매개변수

이름	타입	필수
tenantId	string	예
bulkPreBanParams	BulkPreBanParams	예
options	const PostBulkPreBanSummaryOptions&	예

응답

반환: BulkPreBanSummary

예시

postBulkPreBanSummary 예시

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

ID별 댓글 가져오기

매개변수

이름	형식	필수
tenantId	string	예
commentsByIdsParams	CommentsByIdsParams	예
sso	string	아니오

응답

반환: ModerationAPIChildCommentsResponse

예시

postCommentsByIds 예시

Copy

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

댓글 신고

매개변수

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
options	const PostFlagCommentOptions&	Yes

응답

Returns: APIEmptyResponse

예시

postFlagComment 예시

Copy

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

댓글 제거

매개변수

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
options	const PostRemoveCommentOptions&	Yes

응답

반환: PostRemoveCommentApiResponse

예시

postRemoveComment 예제

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();
            // 응답 처리
        } catch (const std::exception& ex) {
            // 오류 처리
        }
    });

삭제된 댓글 복원

매개변수

이름	유형	필수
tenantId	string	Yes
commentId	string	Yes
options	const PostRestoreDeletedCommentOptions&	Yes

응답

반환: APIEmptyResponse

예시

postRestoreDeletedComment 예제

Copy

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

댓글 승인 상태 설정

매개변수

이름	유형	필수
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentApprovalStatusOptions&	Yes

응답

반환: SetCommentApprovedResponse

예시

postSetCommentApprovalStatus 예시

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

댓글 검토 상태 설정

파라미터

이름	유형	필수
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentReviewStatusOptions&	Yes

응답

반환: APIEmptyResponse

예시

postSetCommentReviewStatus 예시

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

댓글 스팸 상태 설정

매개변수

이름	타입	필수
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentSpamStatusOptions&	Yes

응답

반환: APIEmptyResponse

예제

postSetCommentSpamStatus 예제

Copy

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

댓글 텍스트 설정

매개변수

이름	형식	필수
tenantId	string	Yes
commentId	string	Yes
setCommentTextParams	SetCommentTextParams	Yes
options	const PostSetCommentTextOptions&	Yes

응답

반환: SetCommentTextResponse

예시

postSetCommentText 예시

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

댓글 신고 해제

매개변수

이름	형식	필수
tenantId	string	예
commentId	string	예
options	const PostUnFlagCommentOptions&	예

응답

반환: APIEmptyResponse

예제

postUnFlagComment 예제

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
PostUnFlagCommentOptions opts;
opts.notifyUser = boost::optional<bool>(true);
api->postUnFlagComment(tenantId, commentId, opts)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // 여기에서 처리를 수행할 수 있습니다
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

투표 등록

매개변수

이름	형식	필수
tenantId	string	예
commentId	string	예
options	const PostVoteOptions&	예

응답

반환: VoteResponse

예시

postVote 예제

Copy

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

배지 수여

매개변수

Name	Type	Required
tenantId	string	예
badgeId	string	예
options	const PutAwardBadgeOptions&	예

응답

반환: AwardUserBadgeResponse

예제

putAwardBadge 예제

Copy

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

스레드 닫기

매개변수

이름	유형	필요
tenantId	string	예
urlId	string	예
sso	string	아니오

응답

반환: APIEmptyResponse

예제

putCloseThread 예제

Copy

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

배지 제거

매개변수

이름	유형	필수
tenantId	string	Yes
badgeId	string	Yes
options	const PutRemoveBadgeOptions&	Yes

응답

반환: RemoveUserBadgeResponse

예시

putRemoveBadge 예시

Copy

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

스레드 재열기

매개변수

이름	유형	필수
tenantId	string	예
urlId	string	예
sso	string	아니오

응답

반환: APIEmptyResponse

예시

putReopenThread 예시

Copy

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

신뢰 요소 설정

매개변수

이름	형식	필수	설명
tenantId	string	Yes
options	const SetTrustFactorOptions&	Yes

응답

반환: SetUserTrustFactorResponse

예시

setTrustFactor 예시

Copy

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

중재자 생성

매개변수

Name	Type	Required	Description
tenantId	string	Yes
createModeratorBody	CreateModeratorBody	Yes

응답

반환: CreateModeratorResponse

예시

createModerator 예제

Copy

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

중재자 삭제

매개변수

이름	타입	필수
tenantId	string	예
id	string	예
sendEmail	string	아니오

응답

Returns: APIEmptyResponse

예시

deleteModerator 예시

Copy

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

중재자 가져오기

매개변수

Name	Type	Required	Description
tenantId	string	예
id	string	예

응답

반환: GetModeratorResponse

예제

getModerator 예제

Copy

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

중재자 목록 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	예
skip	double	아니오

응답

반환: GetModeratorsResponse

예시

getModerators 예시

Copy

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

초대 전송

매개변수

이름	유형	필수
tenantId	string	예
id	string	예
fromName	string	예

응답

반환: APIEmptyResponse

예시

sendInvite 예시

Copy

boost::optional<utility::string_t> cc = utility::conversions::to_string_t("cc@example.com");
api->sendInvite(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("invitee@example.com"),
    utility::conversions::to_string_t("John Doe")
).then([](std::shared_ptr<APIEmptyResponse> resp) {
    // 성공적인 초대를 처리합니다
});

중재자 업데이트

매개변수

이름	유형	필수
tenantId	string	Yes
id	string	Yes
updateModeratorBody	UpdateModeratorBody	Yes

응답

반환: APIEmptyResponse

예시

updateModerator 예제

Copy

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

알림 카운트 삭제

매개변수

이름	유형	필수	설명
tenantId	string	예
id	string	예

응답

반환: APIEmptyResponse

예제

deleteNotificationCount 예제

Copy

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

캐시된 알림 카운트 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	Yes
id	string	Yes

응답

반환: GetCachedNotificationCountResponse

예제

getCachedNotificationCount 예제

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();
            // 응답 처리
        } catch (const std::exception&) {
            // 오류 처리
        }
    });

알림 카운트 가져오기

매개변수

이름	형식	필수	설명
tenantId	string	예
options	const GetNotificationCountOptions&	예

응답

반환: GetNotificationCountResponse

예제

getNotificationCount 예제

Copy

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

알림 가져오기

Parameters

이름	형식	필수	설명
tenantId	string	예
options	const GetNotificationsOptions&	예

Response

반환: GetNotificationsResponse

Example

getNotifications 예시

Copy

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

알림 업데이트

매개변수

이름	유형	필수
tenantId	string	예
id	string	예
updateNotificationBody	UpdateNotificationBody	예
userId	string	아니오

응답

Returns: APIEmptyResponse

예시

updateNotification 예시

Copy

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

V1 페이지 반응 생성

매개변수

이름	유형	필수
tenantId	string	예
urlId	string	예
title	string	아니오

응답

반환: CreateV1PageReact

예시

createV1PageReact 예시

Copy

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

V2 페이지 반응 생성

매개변수

이름	유형	필수
tenantId	string	Yes
urlId	string	Yes
id	string	Yes
title	string	No

응답

반환: CreateV1PageReact

예시

createV2PageReact 예시

Copy

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

V1 페이지 반응 삭제

매개변수

이름	형식	필수	설명
tenantId	string	예
urlId	string	예

응답

반환: CreateV1PageReact

예제

deleteV1PageReact 예시

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

V2 페이지 반응 삭제

매개변수

이름	유형	필수
tenantId	string	Yes
urlId	string	Yes
id	string	Yes

응답

반환: CreateV1PageReact

예시

deleteV2PageReact 예제

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

V1 페이지 좋아요 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	예
urlId	string	예

응답

반환: GetV1PageLikes

예제

getV1PageLikes 예제

Copy

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

V2 페이지 반응 가져오기

매개변수

이름	형식	필수	설명
tenantId	string	Yes
urlId	string	Yes

응답

반환: GetV2PageReacts

예시

getV2PageReacts 예시

Copy

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

V2 페이지 반응 사용자 가져오기

매개변수

이름	유형	필수
tenantId	string	Yes
urlId	string	Yes
id	string	Yes

응답

반환: GetV2PageReactUsersResponse

예제

getV2PageReactUsers 예제

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto urlId = utility::conversions::to_string_t("page-456");
auto id = utility::conversions::to_string_t("react-789");
boost::optional<utility::string_t> maybeFilter;
api->getV2PageReactUsers(tenantId, urlId, id).then([](pplx::task<std::shared_ptr<GetV2PageReactUsersResponse>> task){
    try{
        auto response = task.get();
        // 필요에 따라 응답 사용
    }catch(const std::exception&){
        // 오류 처리
    }
});

페이지 추가

매개변수

이름	유형	필수	설명
tenantId	string	예
createAPIPageData	CreateAPIPageData	예

응답

반환: AddPageAPIResponse

예시

addPage 예시

Copy

auto createData = CreateAPIPageData{};
createData.title = utility::string_t(U("Welcome Page"));
createData.url = utility::string_t(U("https://example.com/welcome"));
createData.description = boost::optional<utility::string_t>(utility::string_t(U("Landing page for new users")));
api->addPage(utility::string_t(U("my-tenant-123")), createData)
    .then([](std::shared_ptr<AddPageAPIResponse> response) {
        if (response && response->success) {
            // 성공적인 추가 처리
        } else {
            // 오류 처리
        }
    });

페이지 삭제

매개변수

이름	형식	필수	설명
tenantId	string	Yes
id	string	Yes

응답

반환: DeletePageAPIResponse

예제

deletePage 예제

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();
           // 필요에 따라 응답을 처리합니다
       } catch (const std::exception& ex) {
           // 오류를 처리합니다
       }
   });

오프라인 사용자 가져오기

현재 온라인 상태가 아닌, 해당 페이지의 과거 댓글 작성자입니다. displayName 기준으로 정렬됩니다. "Members" 섹션을 렌더링할 때 /users/online을 모두 소진한 후 이 API를 사용하세요. commenterName 기준 커서 페이지네이션: 서버는 부분 {tenantId, urlId, commenterName} 인덱스를 afterName부터 $gt로 순회하며, $skip 비용이 없습니다.

매개변수

이름	타입	필수
tenantId	string	예
urlId	string	예
options	const GetOfflineUsersOptions&	예

응답

반환값: PageUsersOfflineResponse

예제

getOfflineUsers 예제

Copy

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

온라인 사용자 가져오기

Currently-online viewers of a page: 현재 웹소켓 세션이 해당 페이지에 구독 중인 사람들.

Returns anonCount + totalCount (room-wide subscribers, including anon viewers we don't enumerate).: anonCount + totalCount를 반환합니다 (방 전체 구독자 수, 열거되지 않은 익명 뷰어 포함).

Parameters

이름	타입	필수
tenantId	string	Yes
urlId	string	Yes
options	const GetOnlineUsersOptions&	Yes

Response

반환: PageUsersOnlineResponse

Example

getOnlineUsers 예제

Copy

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

URL ID로 페이지 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	예
urlId	string	예

응답

반환: GetPageByURLIdAPIResponse

예시

getPageByURLId 예시

Copy

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

페이지 목록 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	Yes

응답

반환: GetPagesAPIResponse

예시

getPages 예시

Copy

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

공개 페이지 목록 가져오기

테넌트의 페이지 목록을 가져옵니다. FChat 데스크톱 클라이언트가 방 목록을 채우는 데 사용됩니다. 각 페이지에 대한 해결된 사용자 정의 구성에서 enableFChat가 true이어야 합니다. SSO가 필요한 페이지는 요청 사용자의 그룹 접근 권한에 따라 필터링됩니다.

Parameters

이름	유형	필수	설명
tenantId	string	Yes
options	const GetPagesPublicOptions&	Yes

응답

반환: GetPublicPagesResponse

예제

getPagesPublic 예제

Copy

utility::string_t tenantId = U("my-tenant-123");
GetPagesPublicOptions options;
options.limit = boost::optional<int>(50);
options.cursor = boost::optional<utility::string_t>(U("cursor-token"));
api->getPagesPublic(tenantId, options).then([](pplx::task<std::shared_ptr<GetPublicPagesResponse>> task){
    try{
        auto response = task.get();
        // 필요에 따라 응답 처리
    }catch(const std::exception&){
        // 필요에 따라 오류 처리
    }
});

사용자 정보 가져오기

테넌트에 대한 대량 사용자 정보. 주어진 userIds에 대해 User / SSOUser의 표시 정보를 반환합니다.
댓글 위젯에서 존재 이벤트를 통해 방금 등장한 사용자를 풍부하게 표시하기 위해 사용됩니다.
페이지 컨텍스트가 없으며: 프라이버시가 일관되게 적용됩니다 (비공개 프로필은 마스킹됩니다).

매개변수

이름	유형	필수	설명
tenantId	string	Yes
ids	string	Yes

응답

반환: PageUsersInfoResponse

예시

getUsersInfo 예시

Copy

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

페이지 패치

매개변수

이름	유형	필수
tenantId	string	Yes
id	string	Yes
updateAPIPageData	UpdateAPIPageData	Yes

응답

반환: PatchPageAPIResponse

예시

patchPage 예시

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

보류 중인 웹훅 이벤트 삭제

매개변수

이름	유형	필수	설명
tenantId	string	Yes
id	string	Yes

응답

Returns: APIEmptyResponse

예시

deletePendingWebhookEvent 예시

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

보류 중인 웹훅 이벤트 카운트 가져오기

Parameters

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

Response

반환: GetPendingWebhookEventCountResponse

Example

getPendingWebhookEventCount 예시

Copy

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

보류 중인 웹훅 이벤트 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	Yes
options	const GetPendingWebhookEventsOptions&	Yes

응답

반환: GetPendingWebhookEventsResponse

예제

getPendingWebhookEvents 예제

Copy

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

질문 설정 생성

매개변수

이름	유형	필수	설명
tenantId	string	예
createQuestionConfigBody	CreateQuestionConfigBody	예

응답

반환: CreateQuestionConfigResponse

예제

createQuestionConfig 예제

Copy

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

질문 설정 삭제

매개변수

이름	유형	필수	설명
tenantId	string	예
id	string	예

응답

반환: APIEmptyResponse

예시

deleteQuestionConfig 예시

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto configId = utility::conversions::to_string_t("question-config-456");
api->deleteQuestionConfig(tenantId, configId)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // 성공적인 삭제 처리
    })
    .then([](pplx::task<void> t) {
        try {
            t.get();
        } catch (const std::exception&) {
            // 오류 처리
        }
    });

질문 설정 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	Yes
id	string	Yes

응답

반환: GetQuestionConfigResponse

예제

getQuestionConfig 예제

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto questionId = utility::conversions::to_string_t("question-456");
api->getQuestionConfig(tenantId, questionId)
    .then([](pplx::task<std::shared_ptr<GetQuestionConfigResponse>> task) {
        try {
            auto response = task.get();
            // 필요에 따라 응답 사용
        } catch (const std::exception&) {
            // 오류 처리
        }
    });

질문 설정 목록 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	예
skip	double	아니오

응답

반환: GetQuestionConfigsResponse

예제

getQuestionConfigs 예제

Copy

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

질문 설정 업데이트

매개변수

이름	유형	필수
tenantId	string	예
id	string	예
updateQuestionConfigBody	UpdateQuestionConfigBody	예

응답

반환: APIEmptyResponse

예시

updateQuestionConfig 예시

Copy

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

질문 결과 생성

매개변수

이름	타입	필수	설명
tenantId	string	예
createQuestionResultBody	CreateQuestionResultBody	예

응답

반환: CreateQuestionResultResponse

예제

createQuestionResult 예시

Copy

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

질문 결과 삭제

Parameters

이름	유형	필수	설명
tenantId	string	예
id	string	예

Response

반환: APIEmptyResponse

예시

deleteQuestionResult 예시

Copy

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

질문 결과 가져오기

매개변수

이름	형식	필수	설명
tenantId	string	예
id	string	예

응답

반환: GetQuestionResultResponse

예시

getQuestionResult 예시

Copy

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

질문 결과 목록 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	예
options	const GetQuestionResultsOptions&	예

응답

반환: GetQuestionResultsResponse

예시

getQuestionResults 예시

Copy

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

질문 결과 업데이트

매개변수

이름	유형	필수
tenantId	string	예
id	string	예
updateQuestionResultBody	UpdateQuestionResultBody	예

응답

반환: APIEmptyResponse

예시

updateQuestionResult 예시

Copy

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

질문 결과 집계

매개변수

이름	유형	필수	설명
tenantId	string	예
options	const AggregateQuestionResultsOptions&	예

응답

반환: AggregateQuestionResultsResponse

예제

aggregateQuestionResults 예제

Copy

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

대량 질문 결과 집계

매개변수

이름	타입	필수
tenantId	string	Yes
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Yes
forceRecalculate	bool	No

응답

반환: BulkAggregateQuestionResultsResponse

예시

bulkAggregateQuestionResults 예시

Copy

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

댓글과 질문 결과 결합

매개변수

이름	유형	필수	설명
tenantId	string	Yes
options	const CombineCommentsWithQuestionResultsOptions&	Yes

응답

반환: CombineQuestionResultsWithCommentsResponse

예시

combineCommentsWithQuestionResults 예시

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);
            // 필요에 따라 combined 사용
        }catch(const std::exception&){
        }
    });

SSO 사용자 추가

매개변수

이름	타입	필수	설명
tenantId	string	Yes
createAPISSOUserData	CreateAPISSOUserData	Yes

응답

반환: AddSSOUserAPIResponse

예시

addSSOUser 예시

Copy

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

SSO 사용자 삭제

Parameters

이름	유형	필수
tenantId	string	예
id	string	예
options	const DeleteSSOUserOptions&	예

응답

반환: DeleteSSOUserAPIResponse

예시

deleteSSOUser 예시

Copy

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

이메일로 SSO 사용자 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	예
email	string	예

응답

반환: GetSSOUserByEmailAPIResponse

예시

getSSOUserByEmail 예시

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

ID로 SSO 사용자 가져오기

매개변수

이름	형식	필수	설명
tenantId	string	예
id	string	예

응답

반환: GetSSOUserByIdAPIResponse

예제

getSSOUserById 예제

Copy

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

SSO 사용자 목록 가져오기

매개변수

이름	형식	필수	설명
tenantId	string	예
skip	int32_t	아니오

응답

반환: GetSSOUsersResponse

예제

getSSOUsers 예제

Copy

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

SSO 사용자 패치

매개변수

이름	유형	필수
tenantId	string	예
id	string	예
updateAPISSOUserData	UpdateAPISSOUserData	예
updateComments	bool	아니오

응답

반환: PatchSSOUserAPIResponse

예시

patchSSOUser 예시

Copy

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

SSO 사용자 저장

매개변수

이름	유형	필수
tenantId	string	Yes
id	string	Yes
updateAPISSOUserData	UpdateAPISSOUserData	Yes
updateComments	bool	No

응답

반환: PutSSOUserAPIResponse

예시

putSSOUser 예시

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

구독 생성

매개변수

이름	유형	필수	설명
tenantId	string	예
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	예

응답

반환: CreateSubscriptionAPIResponse

예시

createSubscription 예시

Copy

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

구독 삭제

매개변수

이름	유형	필수
tenantId	string	Yes
id	string	Yes
userId	string	No

응답

반환: DeleteSubscriptionAPIResponse

예시

deleteSubscription 예시

Copy

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

구독 목록 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	예
userId	string	아니오

응답

Returns: GetSubscriptionsAPIResponse

예시

getSubscriptions 예시

Copy

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

구독 업데이트

Parameters

이름	타입	필수
tenantId	string	예
id	string	예
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	예
userId	string	아니오

Response

반환: UpdateSubscriptionAPIResponse

Example

updateSubscription 예시

Copy

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

테넌트 일일 사용량 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	Yes
options	const GetTenantDailyUsagesOptions&	Yes

응답

반환: GetTenantDailyUsagesResponse

예시

getTenantDailyUsages 예제

Copy

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

테넌트 패키지 생성

매개변수

이름	형식	Required	설명
tenantId	string	Yes
createTenantPackageBody	CreateTenantPackageBody	Yes

응답

반환: CreateTenantPackageResponse

예시

createTenantPackage 예시

Copy

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

테넌트 패키지 삭제

매개변수

이름	타입	필수	설명
tenantId	string	예
id	string	예

응답

반환: APIEmptyResponse

예시

deleteTenantPackage 예시

Copy

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

테넌트 패키지 가져오기

매개변수

이름	타입	필수	설명
tenantId	string	Yes
id	string	Yes

응답

반환: GetTenantPackageResponse

예시

getTenantPackage 예시

Copy

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

테넌트 패키지 목록 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	Yes
skip	double	No

응답

반환: GetTenantPackagesResponse

예제

getTenantPackages 예제

Copy

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

테넌트 패키지 교체

매개변수

이름	유형	필수
tenantId	string	Yes
id	string	Yes
replaceTenantPackageBody	ReplaceTenantPackageBody	Yes

응답

반환값: APIEmptyResponse

예시

replaceTenantPackage 예시

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

테넌트 패키지 업데이트

매개변수

이름	타입	필수
tenantId	string	예
id	string	예
updateTenantPackageBody	UpdateTenantPackageBody	예

응답

반환: APIEmptyResponse

예시

updateTenantPackage 예시

Copy

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

테넌트 사용자 생성

매개변수

이름	유형	필수	설명
tenantId	string	예
createTenantUserBody	CreateTenantUserBody	예

응답

반환: CreateTenantUserResponse

예시

createTenantUser 예시

Copy

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

테넌트 사용자 삭제

매개변수

이름	타입	필수
tenantId	string	Yes
id	string	Yes
options	const DeleteTenantUserOptions&	Yes

응답

반환: APIEmptyResponse

예시

deleteTenantUser 예제

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

테넌트 사용자 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	Yes
id	string	Yes

응답

반환: GetTenantUserResponse

예시

getTenantUser 예시

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user@example.com");
api->getTenantUser(tenantId, userId)
    .then([](pplx::task<std::shared_ptr<GetTenantUserResponse>> task) {
        try {
            auto response = task.get();
            // 필요한 경우 응답 사용
        } catch (const std::exception&) {
            // 오류 처리
        }
    });

테넌트 사용자 목록 가져오기

매개변수

Name	Type	Required	Description
tenantId	string	예
skip	double	아니오

응답

반환: GetTenantUsersResponse

예시

getTenantUsers 예시

Copy

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

테넌트 사용자 교체

매개변수

이름	타입	필수
tenantId	string	Yes
id	string	Yes
replaceTenantUserBody	ReplaceTenantUserBody	Yes
updateComments	string	No

응답

반환: APIEmptyResponse

예시

replaceTenantUser 예시

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

로그인 링크 전송

매개변수

이름	유형	필수
tenantId	string	Yes
id	string	Yes
redirectURL	string	No

응답

반환: APIEmptyResponse

예시

sendLoginLink 예시

Copy

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

테넌트 사용자 업데이트

매개변수

이름	유형	필수
tenantId	string	예
id	string	예
updateTenantUserBody	UpdateTenantUserBody	예
updateComments	string	아니오

응답

반환: APIEmptyResponse

예제

updateTenantUser 예제

Copy

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

테넌트 생성

매개변수

이름	타입	필수	설명
tenantId	string	Yes
createTenantBody	CreateTenantBody	Yes

응답

반환: CreateTenantResponse

예시

createTenant 예제

Copy

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

테넌트 삭제

매개변수

이름	유형	필수
tenantId	string	예
id	string	예
sure	string	아니오

응답

반환: APIEmptyResponse

예시

deleteTenant 예시

Copy

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

테넌트 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	예
id	string	예

응답

반환: GetTenantResponse

예제

getTenant 예제

Copy

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

테넌트 목록 가져오기

매개변수

이름	타입	필수	설명
tenantId	string	예
options	const GetTenantsOptions&	예

응답

반환: GetTenantsResponse

예제

getTenants 예제

Copy

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

테넌트 업데이트

매개변수

이름	유형	필수
tenantId	string	Yes
id	string	Yes
updateTenantBody	UpdateTenantBody	Yes

응답

반환: APIEmptyResponse

예제

updateTenant 예제

Copy

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

티켓 상태 변경

매개변수

이름	유형	필수
tenantId	string	예
userId	string	예
id	string	예
changeTicketStateBody	ChangeTicketStateBody	예

응답

반환: ChangeTicketStateResponse

예제

changeTicketState 예제

Copy

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

티켓 생성

매개변수

이름	유형	필수
tenantId	string	예
userId	string	예
createTicketBody	CreateTicketBody	예

응답

반환: CreateTicketResponse

예시

createTicket 예제

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("john.doe@example.com");
CreateTicketBody ticketBody;
ticketBody.setSubject(utility::conversions::to_string_t("Login Issue"));
ticketBody.setDescription(utility::conversions::to_string_t("Cannot log in after password reset."));
boost::optional<int> priority = 2;
ticketBody.setPriority(priority);
api->createTicket(tenantId, userId, ticketBody).then([](pplx::task<std::shared_ptr<CreateTicketResponse>> task){
    try{
        auto response = task.get();
        // 응답을 필요한 대로 사용합니다
    }catch(const std::exception&){
        // 오류 처리
    }
});

티켓 가져오기

매개변수

이름	유형	필수
tenantId	string	예
id	string	예
userId	string	아니오

응답

반환: GetTicketResponse

예시

getTicket 예시

Copy

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

티켓 목록 가져오기

매개변수

이름	타입	필요	설명
tenantId	string	Yes
options	const GetTicketsOptions&	Yes

응답

반환: GetTicketsResponse

예시

getTickets 예시

Copy

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

번역 가져오기

매개변수

이름	타입	필수
r_namespace	string	예
component	string	예
options	const GetTranslationsOptions&	예

응답

반환: GetTranslationsResponse

예제

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

이미지 업로드

이미지를 업로드하고 크기를 조정하기

매개변수

이름	형식	필수
tenantId	string	Yes
file	HttpContent	Yes
options	const UploadImageOptions&	Yes

응답

반환: UploadImageResponse

예시

uploadImage 예시

Copy

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

배지 진행 상황(ID) 가져오기

매개변수

이름	타입	필수	설명
tenantId	string	예
id	string	예

응답

반환: APIGetUserBadgeProgressResponse

예시

getUserBadgeProgressById 예시

Copy

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

배지 진행 상황(사용자 ID) 가져오기

매개변수

이름	타입	필수	설명
tenantId	string	Yes
userId	string	Yes

응답

반환: APIGetUserBadgeProgressResponse

예제

getUserBadgeProgressByUserId 예제

Copy

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

배지 진행 목록 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	예
options	const GetUserBadgeProgressListOptions&	예

응답

반환: APIGetUserBadgeProgressListResponse

예시

getUserBadgeProgressList 예시

Copy

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

사용자 배지 생성

매개변수

이름	유형	필수	설명
tenantId	string	예
createUserBadgeParams	CreateUserBadgeParams	예

응답

반환: APICreateUserBadgeResponse

예시

createUserBadge 예제

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

사용자 배지 삭제

Parameters

이름	타입	필수	설명
tenantId	string	Yes
id	string	Yes

Response

반환: APIEmptySuccessResponse

Example

deleteUserBadge 예시

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

사용자 배지 가져오기

Parameters

이름	타입	필수	설명
tenantId	string	예
id	string	예

Response

반환: APIGetUserBadgeResponse

Example

getUserBadge 예제

Copy

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

사용자 배지 목록 가져오기

매개변수

이름	형식	필수	설명
tenantId	string	Yes
options	const GetUserBadgesOptions&	Yes

응답

반환: APIGetUserBadgesResponse

예시

getUserBadges 예제

Copy

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

사용자 배지 업데이트

매개변수

이름	유형	필수
tenantId	string	Yes
id	string	Yes
updateUserBadgeParams	UpdateUserBadgeParams	Yes

응답

반환: APIEmptySuccessResponse

예제

updateUserBadge 예제

Copy

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

사용자 알림 카운트 가져오기

Parameters

이름	유형	필수	설명
tenantId	string	Yes
sso	string	No

응답

반환: GetUserNotificationCountResponse

예시

getUserNotificationCount 예시

Copy

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

사용자 알림 가져오기

매개변수

이름	형식	필수	설명
tenantId	string	예
options	const GetUserNotificationsOptions&	예

응답

반환: GetMyNotificationsResponse

예시

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

사용자 알림 카운트 초기화

매개변수

이름	유형	필수	설명
tenantId	string	예
sso	string	아니오

응답

반환: ResetUserNotificationsResponse

예시

resetUserNotificationCount 예시

Copy

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

사용자 알림 초기화

Parameters

이름	유형	필수	설명
tenantId	string	예
options	const ResetUserNotificationsOptions&	예

Response

반환: ResetUserNotificationsResponse

Example

resetUserNotifications 예제

Copy

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

사용자 알림 댓글 구독 상태 업데이트

Enable or disable notifications for a specific comment.

Parameters

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

Response

반환: UpdateUserNotificationCommentSubscriptionStatusResponse

Example

updateUserNotificationCommentSubscriptionStatus 예제

Copy

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

사용자 알림 페이지 구독 상태 업데이트

Enable or disable notifications for a page. When users are subscribed to a page, notifications are created for new root comments, and also

Parameters

이름	유형	필수
tenantId	string	Yes
urlId	string	Yes
url	string	Yes
pageTitle	string	Yes
subscribedOrUnsubscribed	string	Yes
sso	string	No

Response

반환: UpdateUserNotificationPageSubscriptionStatusResponse

Example

updateUserNotificationPageSubscriptionStatus 예제

Copy

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

사용자 알림 상태 업데이트

매개변수

Name	Type	Required
tenantId	string	Yes
notificationId	string	Yes
newStatus	string	Yes
sso	string	No

응답

Returns: UpdateUserNotificationStatusResponse

예시

updateUserNotificationStatus 예시

Copy

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

사용자 존재 상태 가져오기

매개변수

이름	유형	필수
tenantId	string	예
urlIdWS	string	예
userIds	string	예

응답

반환: GetUserPresenceStatusesResponse

예시

getUserPresenceStatuses 예시

Copy

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

사용자 검색

매개변수

이름	타입	필수
tenantId	string	Yes
urlId	string	Yes
options	const SearchUsersOptions&	Yes

응답

반환: SearchUsersResult

예시

searchUsers 예시

Copy

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

사용자 가져오기

매개변수

이름	유형	필수	설명
tenantId	string	Yes
id	string	Yes

응답

반환: GetUserResponse

예시

getUser 예제

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user-789");
boost::optional<utility::string_t> optTag = boost::none;
api->getUser(tenantId, userId)
    .then([=](pplx::task<std::shared_ptr<GetUserResponse>> task) {
        try {
            auto response = task.get();
            if (!response) {
                response = std::make_shared<GetUserResponse>();
            }
            // 응답을 필요에 따라 처리
        } catch (const std::exception&) {
            // 오류 처리
        }
    });

투표 생성

매개변수

이름	유형	필수
tenantId	string	예
commentId	string	예
direction	string	예
options	const CreateVoteOptions&	예

응답

반환: VoteResponse

예시

createVote 예시

Copy

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

투표 삭제

매개변수

이름	유형	필수
tenantId	string	예
id	string	예
editKey	string	아니오

응답

반환: VoteDeleteResponse

예시

deleteVote 예시

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto voteId = utility::conversions::to_string_t("vote-9876");
boost::optional<utility::string_t> editKey = utility::conversions::to_string_t("edit-abc123");
api->deleteVote(tenantId, voteId, editKey).then([](pplx::task<std::shared_ptr<VoteDeleteResponse>> task) {
    try {
        auto response = task.get();
        // 필요한 경우 응답 처리
    } catch (const std::exception&) {
        // 오류 처리
    }
});

투표 목록 가져오기

Parameters

Name	Type	Required	Description
tenantId	string	예
urlId	string	예

Response

반환: GetVotesResponse

Example

getVotes 예제

Copy

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

사용자 투표 가져오기

매개변수

이름	유형	필수
tenantId	string	예
urlId	string	예
options	const GetVotesForUserOptions&	예

응답

반환: GetVotesForUserResponse

예시

getVotesForUser 예제

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto urlId = utility::string_t(U("post-456"));
GetVotesForUserOptions options;
options.page = boost::optional<int>(2);
options.pageSize = boost::optional<int>(50);
api->getVotesForUser(tenantId, urlId, options).then([](std::shared_ptr<GetVotesForUserResponse> response) {
    if (response) {
        // 응답을 처리합니다, 예: 투표를 반복합니다
    }
});

도움이 필요하신가요?

C++ SDK 사용 중 문제가 있거나 질문이 있는 경우, 다음을 이용해 주세요:

기여

기여를 환영합니다! 기여 지침은 GitHub 저장소를 방문해 주세요.

언어 🇰🇷 한국어

문서

시작하기

API 참조

사용법

집계

감사 로그

인증

댓글 차단

차단된 댓글 확인

댓글

사용자 댓글

도메인 설정

이메일 템플릿

이벤트 로그

피드 포스트

댓글 신고

GIF

해시태그

중재

중재자

알림 카운트

알림

페이지 반응

페이지

보류 중인 웹훅 이벤트

질문 설정

질문 결과

질문 결과 집계

SSO 사용자

구독

테넌트 일일 사용량

테넌트 패키지

테넌트 사용자

테넌트

티켓

번역

이미지 업로드

사용자 배지 진행

사용자 배지

사용자 알림

사용자 존재 상태

사용자 검색

사용자

투표

FastComments C++ SDK

리포지토리

AI 코딩 에이전트

요구 사항

설치

의존성 설치

소스에서 빌드하기

설치하기

라이브러리 구성

공개 API vs 보안 API

빠른 시작

인증 API 사용하기 (DefaultAPI)

퍼블릭 API 사용하기 (PublicAPI)

모더레이션 API 사용하기 (ModerationApi)

일반적인 문제

API 호출 만들기: 동기 vs 비동기

.get()을 사용한 동기 호출

.then()을 사용한 비동기 호출

동기식과 비동기식 중 선택하기

노트

브로드캐스트 ID

SSO (싱글 사인온)

SSO 사용

간단한 SSO

보안 SSO

fastcomments 문서

Documentation for API Endpoints

Documentation for Models

Documentation for Authorization

api_key

집계

Parameters

Response

Example

감사 로그 가져오기

`.get()`을 사용한 동기 호출

`.then()`을 사용한 비동기 호출