FastComments C++ SDK

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

FastComments API용 공식 C++ SDK

리포지토리

요구사항

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

설치

Install Dependencies

sudo apt install libcpprest-dev libboost-all-dev

Building from Source

mkdir build
cd build
cmake ..
make

Installing

sudo make install

Library Contents

이 라이브러리에는 생성된 API 클라이언트와 API 작업을 더 쉽게 해주는 SSO 유틸리티가 포함되어 있습니다.

API Client Library Docs

Public vs Secured APIs

API 클라이언트에는 DefaultApi, PublicApi, ModerationApi 세 개의 클래스가 있습니다. DefaultApi는 API 키가 필요한 메서드를 포함하고, PublicApi는 브라우저/모바일 장치 등에서 인증 없이 직접 호출할 수 있는 메서드를 포함합니다. ModerationApi는 실시간 및 빠른 모더레이션 API를 광범위하게 제공합니다. 모든 ModerationApi 메서드는 sso 매개변수를 받아들이며, SSO 또는 FastComments.com 세션 쿠키를 통해 인증할 수 있습니다.

빠른 시작

Using Authenticated APIs (DefaultAPI)

Important:

베이스 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>();

    // REQUIRED: 베이스 URL 설정 (지역 선택)
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));  // US
    // OR: config->setBaseUrl(utility::conversions::to_string_t("https://eu.fastcomments.com"));  // EU

    // REQUIRED: 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;
}

Using Public APIs (PublicAPI)

Public endpoints don't require authentication:

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

    // REQUIRED: 베이스 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;
}

Using Moderation APIs (ModerationApi)

The ModerationApi powers the moderator dashboard. Every method accepts an sso parameter so the call runs on behalf of an SSO‑authenticated moderator (see the SSO section below for how to create a token):

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

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

    // REQUIRED: 베이스 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;
}

Common Issues

"URI must contain a hostname" error: ApiClient를 생성하기 전에 config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"))를 호출했는지 확인하십시오. cpp‑restsdk 생성기는 OpenAPI 사양에서 서버 URL을 자동으로 읽어들이지 않습니다.
401 "missing-api-key" error: DefaultAPI 인스턴스를 생성하기 전에 config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY"))를 호출했는지 확인하십시오.
Wrong API class: 서버‑사이드 인증 요청에는 DefaultApi를, 클라이언트‑사이드/공용 요청에는 PublicApi를, 중재자 대시보드 요청(중재자 SSO 토큰으로 인증)에는 ModerationApi를 사용하십시오.

API 호출: 동기 vs 비동기

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

이 SDK의 모든 API 메서드는 C++ REST SDK의 pplx::task<std::shared_ptr<ResponseType>>를 반환합니다. 이는 API 응답을 처리하는 방법에 유연성을 제공합니다.

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

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

요청이 완료될 때까지 호출 스레드를 차단하고 결과를 동기식으로 가져오려면 .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);

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

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

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

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

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

콜백을 사용한 논블로킹 비동기 실행을 위해 .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);

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

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

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

동기와 비동기 선택

The choice depends on your runtime environment and application architecture:

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

.get() (동기 차단)

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

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

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

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

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 문서

API 엔드포인트 문서

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

클래스	메서드	HTTP 요청	설명
DefaultApi	addDomainConfig	POST /api/v1/domain-configs
DefaultApi	addHashTag	POST /api/v1/hash-tags
DefaultApi	addHashTagsBulk	POST /api/v1/hash-tags/bulk
DefaultApi	addPage	POST /api/v1/pages
DefaultApi	addSSOUser	POST /api/v1/sso-users
DefaultApi	aggregate	POST /api/v1/aggregate	groupBy가 제공된 경우 문서를 그룹화하고 여러 작업을 적용하여 문서를 집계합니다. 다양한 작업(예: sum, countDistinct, avg 등)이 지원됩니다.
DefaultApi	aggregateQuestionResults	GET /api/v1/question-results-aggregation
DefaultApi	blockUserFromComment	POST /api/v1/comments/{id}/block
DefaultApi	bulkAggregateQuestionResults	POST /api/v1/question-results-aggregation/bulk
DefaultApi	changeTicketState	PATCH /api/v1/tickets/{id}/state
DefaultApi	combineCommentsWithQuestionResults	GET /api/v1/question-results-aggregation/combine/comments
DefaultApi	createEmailTemplate	POST /api/v1/email-templates
DefaultApi	createFeedPost	POST /api/v1/feed-posts
DefaultApi	createModerator	POST /api/v1/moderators
DefaultApi	createQuestionConfig	POST /api/v1/question-configs
DefaultApi	createQuestionResult	POST /api/v1/question-results
DefaultApi	createSubscription	POST /api/v1/subscriptions
DefaultApi	createTenant	POST /api/v1/tenants
DefaultApi	createTenantPackage	POST /api/v1/tenant-packages
DefaultApi	createTenantUser	POST /api/v1/tenant-users
DefaultApi	createTicket	POST /api/v1/tickets
DefaultApi	createUserBadge	POST /api/v1/user-badges
DefaultApi	createVote	POST /api/v1/votes
DefaultApi	deleteComment	DELETE /api/v1/comments/{id}
DefaultApi	deleteDomainConfig	DELETE /api/v1/domain-configs/{domain}
DefaultApi	deleteEmailTemplate	DELETE /api/v1/email-templates/{id}
DefaultApi	deleteEmailTemplateRenderError	DELETE /api/v1/email-templates/{id}/render-errors/{errorId}
DefaultApi	deleteHashTag	DELETE /api/v1/hash-tags/{tag}
DefaultApi	deleteModerator	DELETE /api/v1/moderators/{id}
DefaultApi	deleteNotificationCount	DELETE /api/v1/notification-count/{id}
DefaultApi	deletePage	DELETE /api/v1/pages/{id}
DefaultApi	deletePendingWebhookEvent	DELETE /api/v1/pending-webhook-events/{id}
DefaultApi	deleteQuestionConfig	DELETE /api/v1/question-configs/{id}
DefaultApi	deleteQuestionResult	DELETE /api/v1/question-results/{id}
DefaultApi	deleteSSOUser	DELETE /api/v1/sso-users/{id}
DefaultApi	deleteSubscription	DELETE /api/v1/subscriptions/{id}
DefaultApi	deleteTenant	DELETE /api/v1/tenants/{id}
DefaultApi	deleteTenantPackage	DELETE /api/v1/tenant-packages/{id}
DefaultApi	deleteTenantUser	DELETE /api/v1/tenant-users/{id}
DefaultApi	deleteUserBadge	DELETE /api/v1/user-badges/{id}
DefaultApi	deleteVote	DELETE /api/v1/votes/{id}
DefaultApi	flagComment	POST /api/v1/comments/{id}/flag
DefaultApi	getAuditLogs	GET /api/v1/audit-logs
DefaultApi	getCachedNotificationCount	GET /api/v1/notification-count/{id}
DefaultApi	getComment	GET /api/v1/comments/{id}
DefaultApi	getComments	GET /api/v1/comments
DefaultApi	getDomainConfig	GET /api/v1/domain-configs/{domain}
DefaultApi	getDomainConfigs	GET /api/v1/domain-configs
DefaultApi	getEmailTemplate	GET /api/v1/email-templates/{id}
DefaultApi	getEmailTemplateDefinitions	GET /api/v1/email-templates/definitions
DefaultApi	getEmailTemplateRenderErrors	GET /api/v1/email-templates/{id}/render-errors
DefaultApi	getEmailTemplates	GET /api/v1/email-templates
DefaultApi	getFeedPosts	GET /api/v1/feed-posts	tenantId와 afterId가 필요합니다.
DefaultApi	getHashTags	GET /api/v1/hash-tags
DefaultApi	getModerator	GET /api/v1/moderators/{id}
DefaultApi	getModerators	GET /api/v1/moderators
DefaultApi	getNotificationCount	GET /api/v1/notifications/count
DefaultApi	getNotifications	GET /api/v1/notifications
DefaultApi	getPageByURLId	GET /api/v1/pages/by-url-id
DefaultApi	getPages	GET /api/v1/pages
DefaultApi	getPendingWebhookEventCount	GET /api/v1/pending-webhook-events/count
DefaultApi	getPendingWebhookEvents	GET /api/v1/pending-webhook-events
DefaultApi	getQuestionConfig	GET /api/v1/question-configs/{id}
DefaultApi	getQuestionConfigs	GET /api/v1/question-configs
DefaultApi	getQuestionResult	GET /api/v1/question-results/{id}
DefaultApi	getQuestionResults	GET /api/v1/question-results
DefaultApi	getSSOUserByEmail	GET /api/v1/sso-users/by-email/{email}
DefaultApi	getSSOUserById	GET /api/v1/sso-users/by-id/{id}
DefaultApi	getSSOUsers	GET /api/v1/sso-users
DefaultApi	getSubscriptions	GET /api/v1/subscriptions
DefaultApi	getTenant	GET /api/v1/tenants/{id}
DefaultApi	getTenantDailyUsages	GET /api/v1/tenant-daily-usage
DefaultApi	getTenantPackage	GET /api/v1/tenant-packages/{id}
DefaultApi	getTenantPackages	GET /api/v1/tenant-packages
DefaultApi	getTenantUser	GET /api/v1/tenant-users/{id}
DefaultApi	getTenantUsers	GET /api/v1/tenant-users
DefaultApi	getTenants	GET /api/v1/tenants
DefaultApi	getTicket	GET /api/v1/tickets/{id}
DefaultApi	getTickets	GET /api/v1/tickets
DefaultApi	getUser	GET /api/v1/users/{id}
DefaultApi	getUserBadge	GET /api/v1/user-badges/{id}
DefaultApi	getUserBadgeProgressById	GET /api/v1/user-badge-progress/{id}
DefaultApi	getUserBadgeProgressByUserId	GET /api/v1/user-badge-progress/user/{userId}
DefaultApi	getUserBadgeProgressList	GET /api/v1/user-badge-progress
DefaultApi	getUserBadges	GET /api/v1/user-badges
DefaultApi	getVotes	GET /api/v1/votes
DefaultApi	getVotesForUser	GET /api/v1/votes/for-user
DefaultApi	patchDomainConfig	PATCH /api/v1/domain-configs/{domainToUpdate}
DefaultApi	patchHashTag	PATCH /api/v1/hash-tags/{tag}
DefaultApi	patchPage	PATCH /api/v1/pages/{id}
DefaultApi	patchSSOUser	PATCH /api/v1/sso-users/{id}
DefaultApi	putDomainConfig	PUT /api/v1/domain-configs/{domainToUpdate}
DefaultApi	putSSOUser	PUT /api/v1/sso-users/{id}
DefaultApi	renderEmailTemplate	POST /api/v1/email-templates/render
DefaultApi	replaceTenantPackage	PUT /api/v1/tenant-packages/{id}
DefaultApi	replaceTenantUser	PUT /api/v1/tenant-users/{id}
DefaultApi	saveComment	POST /api/v1/comments
DefaultApi	saveCommentsBulk	POST /api/v1/comments/bulk
DefaultApi	sendInvite	POST /api/v1/moderators/{id}/send-invite
DefaultApi	sendLoginLink	POST /api/v1/tenant-users/{id}/send-login-link
DefaultApi	unBlockUserFromComment	POST /api/v1/comments/{id}/un-block
DefaultApi	unFlagComment	POST /api/v1/comments/{id}/un-flag
DefaultApi	updateComment	PATCH /api/v1/comments/{id}
DefaultApi	updateEmailTemplate	PATCH /api/v1/email-templates/{id}
DefaultApi	updateFeedPost	PATCH /api/v1/feed-posts/{id}
DefaultApi	updateModerator	PATCH /api/v1/moderators/{id}
DefaultApi	updateNotification	PATCH /api/v1/notifications/{id}
DefaultApi	updateQuestionConfig	PATCH /api/v1/question-configs/{id}
DefaultApi	updateQuestionResult	PATCH /api/v1/question-results/{id}
DefaultApi	updateSubscription	PATCH /api/v1/subscriptions/{id}
DefaultApi	updateTenant	PATCH /api/v1/tenants/{id}
DefaultApi	updateTenantPackage	PATCH /api/v1/tenant-packages/{id}
DefaultApi	updateTenantUser	PATCH /api/v1/tenant-users/{id}
DefaultApi	updateUserBadge	PUT /api/v1/user-badges/{id}
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}	tenantId와 urlId가 필요합니다.
PublicApi	getEventLog	GET /event-log/{tenantId}	tenantId, urlId 및 userIdWS가 필요합니다.
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	tenantId와 afterId가 필요합니다.
PublicApi	getFeedPostsStats	GET /feed-posts/{tenantId}/stats
PublicApi	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}	tenantId, urlId 및 userIdWS가 필요합니다.
PublicApi	getOfflineUsers	GET /pages/{tenantId}/users/offline	현재 온라인이 아닌 페이지의 이전 댓글 작성자들. displayName 순으로 정렬됩니다. /users/online을 모두 사용한 뒤 "멤버" 섹션을 렌더링할 때 사용합니다. commenterName에 대한 커서 페이지네이션: 서버가 afterName 이후로 $gt를 사용해 부분 {tenantId, urlId, commenterName} 인덱스를 탐색하며, $skip 비용이 없습니다.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	페이지의 현재 온라인 시청자: 현재 해당 페이지에 웹소켓 세션이 구독된 사람들. anonCount와 totalCount를 반환합니다 (방 전체 구독자 수, 여기에는 열거되지 않는 익명 시청자도 포함).
PublicApi	getPagesPublic	GET /pages/{tenantId}	테넌트의 페이지 목록을 반환합니다. FChat 데스크톱 클라이언트가 방 목록을 채우는 데 사용됩니다. 각 페이지에 대해 해결된 커스텀 설정에서 `enableFChat`이 true여야 합니다. SSO가 필요한 페이지는 요청 사용자의 그룹 접근 권한에 따라 필터링됩니다.
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	테넌트에 대한 대량 사용자 정보. userIds를 제공하면 User / SSOUser에서 표시 정보를 반환합니다. 댓글 위젯이 존재 이벤트를 통해 새로 나타난 사용자를 풍부하게 만들 때 사용됩니다. 페이지 컨텍스트가 없으므로 프라이버시가 일관되게 적용됩니다 (비공개 프로필은 마스킹됩니다).
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}	특정 댓글에 대한 알림을 활성화하거나 비활성화합니다.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	사용자가 페이지에 가입하면 새 루트 댓글에 대한 알림이 생성됩니다. 또한
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	이미지 업로드 및 리사이즈
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

모델 문서

APIAuditLog
APIBanUserChangeLog
APIBanUserChangedValues
APIBannedUser
APIBannedUserWithMultiMatchInfo
APIComment
APICommentBase
APICommentBase_meta
APICommentCommonBannedUser
APICreateUserBadgeResponse
APIDomainConfiguration
APIEmptyResponse
APIEmptySuccessResponse
APIError
APIGetCommentResponse
APIGetCommentsResponse
APIGetUserBadgeProgressListResponse
APIGetUserBadgeProgressResponse
APIGetUserBadgeResponse
APIGetUserBadgesResponse
APIModerateGetUserBanPreferencesResponse
APIModerateUserBanPreferences
APIPage
APISSOUser
APISaveCommentResponse
APIStatus
APITenant
APITenantDailyUsage
APITicket
[APITicketDetail](https://github.com/FastComments/fastcomments-cpp/blob/master/docs/Models/APITicketDetail

집계

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

댓글 신고 해제

Parameters

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

Response

Returns: FlagCommentResponse

Example

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 아이디 가져오기

매개변수

이름	유형	필수	설명
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){
    // 성공 처리
});

대량 사전 차단 요약 요청

Parameters

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

Response

Returns: BulkPreBanSummary

Example

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

아이디로 댓글 조회

매개변수

이름	형식	필수
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&) {} });

캐시된 알림 수 가져오기

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetCachedNotificationCountResponse

Example

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();
            // process response
        } catch (const std::exception&) {
            // handle error
        }
    });

알림 수 가져오기

매개변수

이름	형식	필수	설명
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) {
           // 오류를 처리합니다
       }
   });

오프라인 사용자 가져오기

Past commenters on the page who are NOT currently online. Sorted by displayName.
현재 온라인이 아닌 페이지의 과거 댓글자들. displayName 기준으로 정렬됩니다.

Use this after exhausting /users/online to render a "Members" section.
/users/online을 사용한 후에, "Members" 섹션을 렌더링하기 위해 사용합니다.

Cursor pagination on commenterName: server walks the partial {tenantId, urlId, commenterName} index from afterName forward via $gt, no $skip cost.
commenterName에 대한 커서 페이지네이션: 서버는 {tenantId, urlId, commenterName} 부분 인덱스를 afterName 이후로 $gt를 사용해 진행하며, $skip 비용이 없습니다.

매개변수

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

응답

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

공개 페이지 목록 가져오기

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.

Parameters

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

Response

Returns: GetPublicPagesResponse

Example

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

사용자 배지 진행 목록 가져오기

Parameters

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

Response

Returns: APIGetUserBadgeProgressListResponse

Example

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

사용자 배지 생성

매개변수

이름	유형	필수	설명
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

리포지토리

요구사항

설치

Install Dependencies

Building from Source

Installing

Library Contents

Public vs Secured APIs

빠른 시작

Using Authenticated APIs (DefaultAPI)

Using Public APIs (PublicAPI)

Using Moderation APIs (ModerationApi)

Common Issues

API 호출: 동기 vs 비동기

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

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

동기와 비동기 선택

참고

브로드캐스트 ID

SSO (싱글 사인온)

SSO 사용법

간단한 SSO

보안 SSO

fastcomments 문서

API 엔드포인트 문서

모델 문서

집계

Parameters

Response

Example

감사 로그 가져오기

매개변수

응답

예시

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

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