FastComments の C++ SDK

これは FastComments の公式 C++ SDK です。

FastComments API の公式 C++ SDK

リポジトリ

要件

C++17 以降
CMake 3.14 以降
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (テストのために自動的にダウンロードされます)

インストール

依存関係のインストール

sudo apt install libcpprest-dev libboost-all-dev

ソースからのビルド

mkdir build
cd build
cmake ..
make

インストール

sudo make install

ライブラリの内容

このライブラリには、生成された API クライアントと、API の利用を簡易にする SSO ユーティリティが含まれています。

API クライアントライブラリのドキュメント

公開 API と保護された API

API クライアントには、DefaultAPI と PublicAPI の2つのクラスがあります。DefaultAPI はあなたの API キーを必要とするメソッドを含み、PublicAPI はブラウザやモバイル端末などから認証なしで直接実行できる API 呼び出しを含みます。

クイックスタート

認証された API の使用 (DefaultAPI)

重要:

ベース URL を設定する必要があります（cpp-restsdk ジェネレータは OpenAPI spec から読み取りません）
認証済みリクエストを行う前に ApiClient の ApiClient に API キーを設定する必要があります。設定しないと、リクエストは 401 エラーになります。

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

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

    // 必須: ベース URL を設定してください（リージョンを選択）
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));  // US
    // または: config->setBaseUrl(utility::conversions::to_string_t("https://eu.fastcomments.com"));  // EU

    // 必須: API キーを設定してください
    config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_API_KEY_HERE"));

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

    // これで認証された API 呼び出しが可能です
    return 0;
}

公開 API の使用 (PublicAPI)

公開エンドポイントは認証を必要としません:

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

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

    // 必須: ベース URL を設定してください
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

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

    // 公開 API を呼び出します
    return 0;
}

よくある問題

"URI must contain a hostname" error: ApiClient を作成する前に config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) を呼び出していることを確認してください。cpp-restsdk ジェネレータは OpenAPI spec からサーバー 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 を使用してください。

API 呼び出し: 同期と非同期

このSDKのすべてのAPIメソッドはC++ REST SDKのpplx::task<std::shared_ptr<ResponseType>>を返します。これにより、APIレスポンスの処理方法に柔軟性が得られます。

`.get()` を使った同期呼び出し

.get() を使用して、リクエストが完了するまで呼び出し元のスレッドをブロックし、結果を同期的に取得します:

auto config = std::make_shared<org::openapitools::client::api::ApiConfiguration>();
config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));
config->setApiKey(utility::conversions::to_string_t("api_key"),
                  utility::conversions::to_string_t("YOUR_API_KEY"));

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

// Call .get() to block and get the result synchronously
auto response = api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    boost::none,  // page
    boost::none,  // limit
    boost::none,  // skip
    boost::none,  // asTree
    boost::none,  // skipChildren
    boost::none,  // limitChildren
    boost::none,  // maxTreeDepth
    utility::conversions::to_string_t("your-url-id"),  // urlId
    boost::none,  // userId
    boost::none,  // anonUserId
    boost::none,  // contextUserId
    boost::none,  // hashTag
    boost::none,  // parentId
    boost::none   // direction
).get();  // Blocks until the HTTP request completes

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

`.then()` を使った非同期呼び出し

コールバックによるノンブロッキングの非同期実行には.then()を使用します:

auto config = std::make_shared<org::openapitools::client::api::ApiConfiguration>();
config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));
config->setApiKey(utility::conversions::to_string_t("api_key"),
                  utility::conversions::to_string_t("YOUR_API_KEY"));

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

// Use .then() for asynchronous callback-based execution
api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    boost::none, boost::none, boost::none, boost::none, boost::none,
    boost::none, boost::none,
    utility::conversions::to_string_t("your-url-id"),
    boost::none, boost::none, boost::none, boost::none, boost::none, boost::none
).then([](std::shared_ptr<GetComments_200_response> response) {
    // 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;

同期と非同期の選択

選択はランタイム環境とアプリケーションのアーキテクチャによります:

.get()（同期ブロッキング）

HTTPリクエストが完了するまで呼び出しスレッドをブロックする
コードの流れが単純で、理解しやすい
専用のワーカースレッド、バッチ処理、またはコマンドラインツールに適している
イベントループ、GUIスレッド、または単一スレッドのサーバーには適していない

.then()（非同期ノンブロッキング）

即座に戻り、リクエスト完了時にコールバックが実行される
呼び出しスレッドをブロックしない
イベント駆動型アーキテクチャ、GUIアプリケーション、または単一スレッドのイベントループでは必要
複数の操作のチェーンを可能にする
制御フローがより複雑になる

このSDKのテストスイートは.get()のみを使用していますが、これはブロッキングが許容されるテスト環境では適切です。

注意事項

ブロードキャストID

いくつかの API 呼び出しでは broadcastId を渡すことになっています。イベントを受信したときにこの ID が返されるので、クライアント側で楽観的に変更を適用する予定がある場合は、そのイベントを無視すべきかを判断できます（おそらく最良の体験を提供するためにそうしたいでしょう）。ここには UUID を渡してください。ID はブラウザセッション内で二度出現しないほど十分に一意であるべきです。

SSO (Single Sign-On)

SSO の例は以下を参照してください。

SSO の使用方法

シンプル SSO

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

using namespace fastcomments::sso;

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

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

セキュア SSO

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

using namespace fastcomments::sso;

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

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

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

fastcomments のドキュメント

APIエンドポイントのドキュメント

すべてのURIは https://fastcomments.com に対して相対的です

クラス	メソッド	HTTPリクエスト	説明
DefaultApi	addDomainConfig	POST /api/v1/domain-configs
DefaultApi	addHashTag	POST /api/v1/hash-tags
DefaultApi	addHashTagsBulk	POST /api/v1/hash-tags/bulk
DefaultApi	addPage	POST /api/v1/pages
DefaultApi	addSSOUser	POST /api/v1/sso-users
DefaultApi	aggregate	POST /api/v1/aggregate	ドキュメントをグループ化（groupByが提供されている場合）して複数の操作を適用して集計します。さまざまな操作（例: sum, countDistinct, avgなど）に対応しています。
DefaultApi	aggregateQuestionResults	GET /api/v1/question-results-aggregation
DefaultApi	blockUserFromComment	POST /api/v1/comments/{id}/block
DefaultApi	bulkAggregateQuestionResults	POST /api/v1/question-results-aggregation/bulk
DefaultApi	changeTicketState	PATCH /api/v1/tickets/{id}/state
DefaultApi	combineCommentsWithQuestionResults	GET /api/v1/question-results-aggregation/combine/comments
DefaultApi	createEmailTemplate	POST /api/v1/email-templates
DefaultApi	createFeedPost	POST /api/v1/feed-posts
DefaultApi	createModerator	POST /api/v1/moderators
DefaultApi	createQuestionConfig	POST /api/v1/question-configs
DefaultApi	createQuestionResult	POST /api/v1/question-results
DefaultApi	createSubscription	POST /api/v1/subscriptions
DefaultApi	createTenant	POST /api/v1/tenants
DefaultApi	createTenantPackage	POST /api/v1/tenant-packages
DefaultApi	createTenantUser	POST /api/v1/tenant-users
DefaultApi	createTicket	POST /api/v1/tickets
DefaultApi	createUserBadge	POST /api/v1/user-badges
DefaultApi	createVote	POST /api/v1/votes
DefaultApi	deleteComment	DELETE /api/v1/comments/{id}
DefaultApi	deleteDomainConfig	DELETE /api/v1/domain-configs/{domain}
DefaultApi	deleteEmailTemplate	DELETE /api/v1/email-templates/{id}
DefaultApi	deleteEmailTemplateRenderError	DELETE /api/v1/email-templates/{id}/render-errors/{errorId}
DefaultApi	deleteHashTag	DELETE /api/v1/hash-tags/{tag}
DefaultApi	deleteModerator	DELETE /api/v1/moderators/{id}
DefaultApi	deleteNotificationCount	DELETE /api/v1/notification-count/{id}
DefaultApi	deletePage	DELETE /api/v1/pages/{id}
DefaultApi	deletePendingWebhookEvent	DELETE /api/v1/pending-webhook-events/{id}
DefaultApi	deleteQuestionConfig	DELETE /api/v1/question-configs/{id}
DefaultApi	deleteQuestionResult	DELETE /api/v1/question-results/{id}
DefaultApi	deleteSSOUser	DELETE /api/v1/sso-users/{id}
DefaultApi	deleteSubscription	DELETE /api/v1/subscriptions/{id}
DefaultApi	deleteTenant	DELETE /api/v1/tenants/{id}
DefaultApi	deleteTenantPackage	DELETE /api/v1/tenant-packages/{id}
DefaultApi	deleteTenantUser	DELETE /api/v1/tenant-users/{id}
DefaultApi	deleteUserBadge	DELETE /api/v1/user-badges/{id}
DefaultApi	deleteVote	DELETE /api/v1/votes/{id}
DefaultApi	flagComment	POST /api/v1/comments/{id}/flag
DefaultApi	getAuditLogs	GET /api/v1/audit-logs
DefaultApi	getCachedNotificationCount	GET /api/v1/notification-count/{id}
DefaultApi	getComment	GET /api/v1/comments/{id}
DefaultApi	getComments	GET /api/v1/comments
DefaultApi	getDomainConfig	GET /api/v1/domain-configs/{domain}
DefaultApi	getDomainConfigs	GET /api/v1/domain-configs
DefaultApi	getEmailTemplate	GET /api/v1/email-templates/{id}
DefaultApi	getEmailTemplateDefinitions	GET /api/v1/email-templates/definitions
DefaultApi	getEmailTemplateRenderErrors	GET /api/v1/email-templates/{id}/render-errors
DefaultApi	getEmailTemplates	GET /api/v1/email-templates
DefaultApi	getFeedPosts	GET /api/v1/feed-posts	必須 tenantId afterId
DefaultApi	getHashTags	GET /api/v1/hash-tags
DefaultApi	getModerator	GET /api/v1/moderators/{id}
DefaultApi	getModerators	GET /api/v1/moderators
DefaultApi	getNotificationCount	GET /api/v1/notifications/count
DefaultApi	getNotifications	GET /api/v1/notifications
DefaultApi	getPageByURLId	GET /api/v1/pages/by-url-id
DefaultApi	getPages	GET /api/v1/pages
DefaultApi	getPendingWebhookEventCount	GET /api/v1/pending-webhook-events/count
DefaultApi	getPendingWebhookEvents	GET /api/v1/pending-webhook-events
DefaultApi	getQuestionConfig	GET /api/v1/question-configs/{id}
DefaultApi	getQuestionConfigs	GET /api/v1/question-configs
DefaultApi	getQuestionResult	GET /api/v1/question-results/{id}
DefaultApi	getQuestionResults	GET /api/v1/question-results
DefaultApi	getSSOUserByEmail	GET /api/v1/sso-users/by-email/{email}
DefaultApi	getSSOUserById	GET /api/v1/sso-users/by-id/{id}
DefaultApi	getSSOUsers	GET /api/v1/sso-users
DefaultApi	getSubscriptions	GET /api/v1/subscriptions
DefaultApi	getTenant	GET /api/v1/tenants/{id}
DefaultApi	getTenantDailyUsages	GET /api/v1/tenant-daily-usage
DefaultApi	getTenantPackage	GET /api/v1/tenant-packages/{id}
DefaultApi	getTenantPackages	GET /api/v1/tenant-packages
DefaultApi	getTenantUser	GET /api/v1/tenant-users/{id}
DefaultApi	getTenantUsers	GET /api/v1/tenant-users
DefaultApi	getTenants	GET /api/v1/tenants
DefaultApi	getTicket	GET /api/v1/tickets/{id}
DefaultApi	getTickets	GET /api/v1/tickets
DefaultApi	getUser	GET /api/v1/users/{id}
DefaultApi	getUserBadge	GET /api/v1/user-badges/{id}
DefaultApi	getUserBadgeProgressById	GET /api/v1/user-badge-progress/{id}
DefaultApi	getUserBadgeProgressByUserId	GET /api/v1/user-badge-progress/user/{userId}
DefaultApi	getUserBadgeProgressList	GET /api/v1/user-badge-progress
DefaultApi	getUserBadges	GET /api/v1/user-badges
DefaultApi	getVotes	GET /api/v1/votes
DefaultApi	getVotesForUser	GET /api/v1/votes/for-user
DefaultApi	patchDomainConfig	PATCH /api/v1/domain-configs/{domainToUpdate}
DefaultApi	patchHashTag	PATCH /api/v1/hash-tags/{tag}
DefaultApi	patchPage	PATCH /api/v1/pages/{id}
DefaultApi	patchSSOUser	PATCH /api/v1/sso-users/{id}
DefaultApi	putDomainConfig	PUT /api/v1/domain-configs/{domainToUpdate}
DefaultApi	putSSOUser	PUT /api/v1/sso-users/{id}
DefaultApi	renderEmailTemplate	POST /api/v1/email-templates/render
DefaultApi	replaceTenantPackage	PUT /api/v1/tenant-packages/{id}
DefaultApi	replaceTenantUser	PUT /api/v1/tenant-users/{id}
DefaultApi	saveComment	POST /api/v1/comments
DefaultApi	saveCommentsBulk	POST /api/v1/comments/bulk
DefaultApi	sendInvite	POST /api/v1/moderators/{id}/send-invite
DefaultApi	sendLoginLink	POST /api/v1/tenant-users/{id}/send-login-link
DefaultApi	unBlockUserFromComment	POST /api/v1/comments/{id}/un-block
DefaultApi	unFlagComment	POST /api/v1/comments/{id}/un-flag
DefaultApi	updateComment	PATCH /api/v1/comments/{id}
DefaultApi	updateEmailTemplate	PATCH /api/v1/email-templates/{id}
DefaultApi	updateFeedPost	PATCH /api/v1/feed-posts/{id}
DefaultApi	updateModerator	PATCH /api/v1/moderators/{id}
DefaultApi	updateNotification	PATCH /api/v1/notifications/{id}
DefaultApi	updateQuestionConfig	PATCH /api/v1/question-configs/{id}
DefaultApi	updateQuestionResult	PATCH /api/v1/question-results/{id}
DefaultApi	updateSubscription	PATCH /api/v1/subscriptions/{id}
DefaultApi	updateTenant	PATCH /api/v1/tenants/{id}
DefaultApi	updateTenantPackage	PATCH /api/v1/tenant-packages/{id}
DefaultApi	updateTenantUser	PATCH /api/v1/tenant-users/{id}
DefaultApi	updateUserBadge	PUT /api/v1/user-badges/{id}
PublicApi	blockFromCommentPublic	POST /block-from-comment/{commentId}
PublicApi	checkedCommentsForBlocked	GET /check-blocked-comments
PublicApi	createCommentPublic	POST /comments/{tenantId}
PublicApi	createFeedPostPublic	POST /feed-posts/{tenantId}
PublicApi	deleteCommentPublic	DELETE /comments/{tenantId}/{commentId}
PublicApi	deleteCommentVote	DELETE /comments/{tenantId}/{commentId}/vote/{voteId}
PublicApi	deleteFeedPostPublic	DELETE /feed-posts/{tenantId}/{postId}
PublicApi	flagCommentPublic	POST /flag-comment/{commentId}
PublicApi	getCommentText	GET /comments/{tenantId}/{commentId}/text
PublicApi	getCommentVoteUserNames	GET /comments/{tenantId}/{commentId}/votes
PublicApi	getCommentsPublic	GET /comments/{tenantId}	必須 tenantId urlId
PublicApi	getEventLog	GET /event-log/{tenantId}	必須 tenantId urlId userIdWS
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	必須 tenantId afterId
PublicApi	getFeedPostsStats	GET /feed-posts/{tenantId}/stats
PublicApi	getGlobalEventLog	GET /event-log/global/{tenantId}	必須 tenantId urlId userIdWS
PublicApi	getUserNotificationCount	GET /user-notifications/get-count
PublicApi	getUserNotifications	GET /user-notifications
PublicApi	getUserPresenceStatuses	GET /user-presence-status
PublicApi	getUserReactsPublic	GET /feed-posts/{tenantId}/user-reacts
PublicApi	lockComment	POST /comments/{tenantId}/{commentId}/lock
PublicApi	pinComment	POST /comments/{tenantId}/{commentId}/pin
PublicApi	reactFeedPostPublic	POST /feed-posts/{tenantId}/react/{postId}
PublicApi	resetUserNotificationCount	POST /user-notifications/reset-count
PublicApi	resetUserNotifications	POST /user-notifications/reset
PublicApi	searchUsers	GET /user-search/{tenantId}
PublicApi	setCommentText	POST /comments/{tenantId}/{commentId}/update-text
PublicApi	unBlockCommentPublic	DELETE /block-from-comment/{commentId}
PublicApi	unLockComment	POST /comments/{tenantId}/{commentId}/unlock
PublicApi	unPinComment	POST /comments/{tenantId}/{commentId}/unpin
PublicApi	updateFeedPostPublic	PUT /feed-posts/{tenantId}/{postId}
PublicApi	updateUserNotificationCommentSubscriptionStatus	POST /user-notifications/{notificationId}/mark-opted/{optedInOrOut}	特定のコメントの通知を有効または無効にします。
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	ページの通知を有効または無効にします。ユーザーがページを購読している場合、新しいルートコメントに対して通知が作成されるほか
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	画像をアップロードしリサイズします
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

モデルのドキュメント

集計

パラメータ

名前	型	必須
tenantId	string	はい
aggregationRequest	AggregationRequest	はい
parentTenantId	string	いいえ
includeStats	bool	いいえ

レスポンス

戻り値: AggregationResponse

例

aggregate の例

Copy

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

監査ログを取得

パラメータ

名前	型	必須
tenantId	string	はい
limit	double	いいえ
skip	double	いいえ
order	SORT_DIR	いいえ
after	double	いいえ
before	double	いいえ

レスポンス

戻り値: GetAuditLogs_200_response

例

getAuditLogs の例

Copy

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

コメントでブロック（公開）

パラメータ

名前	型	必須
tenantId	string	はい
commentId	string	はい
publicBlockFromCommentParams	PublicBlockFromCommentParams	はい
sso	string	いいえ

レスポンス

戻り値: BlockFromCommentPublic_200_response

例

blockFromCommentPublic の例

Copy

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

コメントのブロック解除（公開）

パラメータ

名前	型	必須
tenantId	string	はい
commentId	string	はい
publicBlockFromCommentParams	PublicBlockFromCommentParams	はい
sso	string	いいえ

レスポンス

戻り値: UnBlockCommentPublic_200_response

例

unBlockCommentPublic の例

Copy

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

ブロック対象コメントをチェック

パラメータ

名前	型	必須
tenantId	string	はい
commentIds	string	はい
sso	string	いいえ

レスポンス

戻り値: CheckedCommentsForBlocked_200_response

例

checkedCommentsForBlocked の例

Copy

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

コメントからユーザーをブロック

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
blockFromCommentParams	BlockFromCommentParams	はい
userId	string	いいえ
anonUserId	string	いいえ

レスポンス

戻り値: BlockFromCommentPublic_200_response

例

blockUserFromComment の例

Copy

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

コメント作成（公開）

パラメータ

名前	型	必須
tenantId	string	はい
urlId	string	はい
broadcastId	string	はい
commentData	CommentData	はい
sessionId	string	いいえ
sso	string	いいえ

レスポンス

戻り値: CreateCommentPublic_200_response

例

createCommentPublic の例

Copy

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

コメントを削除

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
contextUserId	string	いいえ
isLive	bool	いいえ

レスポンス

戻り値: DeleteComment_200_response

例

deleteComment の例

Copy

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

コメント削除（公開）

パラメータ

Name	Type	Required
tenantId	string	はい
commentId	string	はい
broadcastId	string	はい
editKey	string	いいえ
sso	string	いいえ

レスポンス

戻り値: DeleteCommentPublic_200_response

例

deleteCommentPublic の例

Copy

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

コメントの投票を削除

パラメーター

名前	型	必須
tenantId	string	はい
commentId	string	はい
voteId	string	はい
urlId	string	はい
broadcastId	string	はい
editKey	string	いいえ
sso	string	いいえ

レスポンス

戻り値: DeleteCommentVote_200_response

例

deleteCommentVote の例

Copy

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

コメントを通報

パラメータ

Name	Type	Required
tenantId	string	はい
id	string	はい
userId	string	いいえ
anonUserId	string	いいえ

レスポンス

戻り値: FlagComment_200_response

例

flagComment の例

Copy

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

コメントを取得

パラメータ

Name	Type	Required	Description
tenantId	string	はい
id	string	はい

レスポンス

戻り値: GetComment_200_response

例

getComment の例

Copy

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

コメント一覧を取得

パラメータ

名前	型	必須
tenantId	string	はい
page	int32_t	いいえ
limit	int32_t	いいえ
skip	int32_t	いいえ
asTree	bool	いいえ
skipChildren	int32_t	いいえ
limitChildren	int32_t	いいえ
maxTreeDepth	int32_t	いいえ
urlId	string	いいえ
userId	string	いいえ
anonUserId	string	いいえ
contextUserId	string	いいえ
hashTag	string	いいえ
parentId	string	いいえ
direction	SortDirections	いいえ

レスポンス

戻り値: GetComments_200_response

例

getComments の例

Copy

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

コメント一覧を取得（公開）

req tenantId urlId

パラメーター

名前	型	必須
tenantId	string	はい
urlId	string	はい
page	int32_t	いいえ
direction	SortDirections	いいえ
sso	string	いいえ
skip	int32_t	いいえ
skipChildren	int32_t	いいえ
limit	int32_t	いいえ
limitChildren	int32_t	いいえ
countChildren	bool	いいえ
fetchPageForCommentId	string	いいえ
includeConfig	bool	いいえ
countAll	bool	いいえ
includei10n	bool	いいえ
locale	string	いいえ
modules	string	いいえ
isCrawler	bool	いいえ
includeNotificationCount	bool	いいえ
asTree	bool	いいえ
maxTreeDepth	int32_t	いいえ
useFullTranslationIds	bool	いいえ
parentId	string	いいえ
searchText	string	いいえ
hashTags	vector<string	いいえ
userId	string	いいえ
customConfigStr	string	いいえ
afterCommentId	string	いいえ
beforeCommentId	string	いいえ

レスポンス

戻り値: GetCommentsPublic_200_response

例

getCommentsPublic の例

Copy

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

コメント本文を取得

パラメータ

名前	型	必須
tenantId	string	はい
commentId	string	はい
editKey	string	いいえ
sso	string	いいえ

レスポンス

戻り値: GetCommentText_200_response

例

getCommentText の例

Copy

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

コメント投票したユーザー名を取得

パラメータ

名前	型	必須
tenantId	string	はい
commentId	string	はい
dir	int32_t	はい
sso	string	いいえ

レスポンス

戻り値: GetCommentVoteUserNames_200_response

例

getCommentVoteUserNames の例

Copy

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

コメントをロック

パラメータ

名前	型	必須
tenantId	string	はい
commentId	string	はい
broadcastId	string	はい
sso	string	いいえ

レスポンス

戻り値: LockComment_200_response

例

lockComment の例

Copy

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

コメントをピン留め

パラメーター

名前	型	必須
tenantId	string	はい
commentId	string	はい
broadcastId	string	はい
sso	string	いいえ

レスポンス

戻り値: PinComment_200_response

例

pinComment の例

Copy

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

コメントを保存

パラメータ

名前	型	必須
tenantId	string	はい
createCommentParams	CreateCommentParams	はい
isLive	bool	いいえ
doSpamCheck	bool	いいえ
sendEmails	bool	いいえ
populateNotifications	bool	いいえ

レスポンス

戻り値: SaveComment_200_response

例

saveComment の例

Copy

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

コメント本文を設定

パラメータ

名前	型	必須
tenantId	string	はい
commentId	string	はい
broadcastId	string	はい
commentTextUpdateRequest	CommentTextUpdateRequest	はい
editKey	string	いいえ
sso	string	いいえ

レスポンス

戻り値: SetCommentText_200_response

例

setCommentText の例

Copy

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

コメントからユーザーのブロック解除

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
unBlockFromCommentParams	UnBlockFromCommentParams	はい
userId	string	いいえ
anonUserId	string	いいえ

レスポンス

戻り値: UnBlockCommentPublic_200_response

例

unBlockUserFromComment の例

Copy

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

コメントの通報を取り消す

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
userId	string	いいえ
anonUserId	string	いいえ

レスポンス

戻り値: FlagComment_200_response

例

unFlagComment の例

Copy

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

コメントのロック解除

パラメータ

名前	タイプ	必須
tenantId	string	はい
commentId	string	はい
broadcastId	string	はい
sso	string	いいえ

レスポンス

戻り値: LockComment_200_response

例

unLockComment の例

Copy

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

コメントのピン留め解除

パラメータ

名前	型	必須
tenantId	string	はい
commentId	string	はい
broadcastId	string	はい
sso	string	いいえ

レスポンス

戻り値: PinComment_200_response

例

unPinComment の例

Copy

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

コメントを更新

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
updatableCommentParams	UpdatableCommentParams	はい
contextUserId	string	いいえ
doSpamCheck	bool	いいえ
isLive	bool	いいえ

レスポンス

戻り値: FlagCommentPublic_200_response

例

updateComment の例

Copy

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

コメントに投票

パラメータ

名前	型	必須
tenantId	string	はい
commentId	string	はい
urlId	string	はい
broadcastId	string	はい
voteBodyParams	VoteBodyParams	はい
sessionId	string	いいえ
sso	string	いいえ

レスポンス

戻り値: VoteComment_200_response

例

voteComment の例

Copy

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

ドメイン設定を追加

パラメータ

名前	型	必須	説明
tenantId	string	はい
addDomainConfigParams	AddDomainConfigParams	はい

レスポンス

戻り値: AddDomainConfig_200_response

例

addDomainConfig の例

Copy

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

ドメイン設定を削除

パラメータ

名前	型	必須	説明
tenantId	string	はい
domain	string	はい

レスポンス

戻り値: DeleteDomainConfig_200_response

例

deleteDomainConfigの例

Copy

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

ドメイン設定を取得

パラメータ

Name	Type	Required	Description
tenantId	string	はい
domain	string	はい

レスポンス

戻り値: GetDomainConfig_200_response

例

getDomainConfig の例

Copy

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

ドメイン設定一覧を取得

パラメータ

名前	型	必須	説明
tenantId	string	はい

レスポンス

戻り値: GetDomainConfigs_200_response

使用例

getDomainConfigs の使用例

Copy

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

ドメイン設定を部分更新

パラメータ

名前	型	必須
tenantId	string	はい
domainToUpdate	string	はい
patchDomainConfigParams	PatchDomainConfigParams	はい

レスポンス

戻り値: GetDomainConfig_200_response

例

patchDomainConfig の例

Copy

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

ドメイン設定を更新（置換）

パラメータ

名前	型	必須
tenantId	string	はい
domainToUpdate	string	はい
updateDomainConfigParams	UpdateDomainConfigParams	はい

レスポンス

戻り値: GetDomainConfig_200_response

例

putDomainConfig の例

Copy

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

メールテンプレートを作成

パラメータ

名前	型	必須	説明
tenantId	string	はい
createEmailTemplateBody	CreateEmailTemplateBody	はい

レスポンス

戻り値: CreateEmailTemplate_200_response

例

createEmailTemplate の例

Copy

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

メールテンプレートを削除

パラメータ

名前	型	必須	説明
tenantId	string	はい
id	string	はい

レスポンス

戻り値: FlagCommentPublic_200_response

例

deleteEmailTemplate の例

Copy

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

メールテンプレートのレンダーエラーを削除

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
errorId	string	はい

レスポンス

戻り値: FlagCommentPublic_200_response

例

deleteEmailTemplateRenderError の例

Copy

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

メールテンプレートを取得

パラメータ

Name	Type	Required	Description
tenantId	string	はい
id	string	はい

レスポンス

返却値: GetEmailTemplate_200_response

例

getEmailTemplate の例

Copy

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

メールテンプレート定義を取得

パラメータ

名前	型	必須	説明
tenantId	string	はい

レスポンス

戻り値: GetEmailTemplateDefinitions_200_response

例

getEmailTemplateDefinitions の例

Copy

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

メールテンプレートのレンダーエラーを取得

パラメータ

名前	型	必須
tenantId	string	Yes
id	string	Yes
skip	double	No

レスポンス

返却値: GetEmailTemplateRenderErrors_200_response

例

getEmailTemplateRenderErrors の例

Copy

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

メールテンプレート一覧を取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
skip	double	いいえ

レスポンス

戻り値: GetEmailTemplates_200_response

例

getEmailTemplates の例

Copy

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

メールテンプレートをレンダリング

パラメータ

名前	型	必須
tenantId	string	はい
renderEmailTemplateBody	RenderEmailTemplateBody	はい
locale	string	いいえ

レスポンス

戻り値: RenderEmailTemplate_200_response

例

renderEmailTemplate の例

Copy

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

メールテンプレートを更新

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
updateEmailTemplateBody	UpdateEmailTemplateBody	はい

レスポンス

戻り値: FlagCommentPublic_200_response

例

updateEmailTemplate の例

Copy

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

イベントログを取得

req tenantId urlId userIdWS

パラメータ

Name	Type	必須
tenantId	string	はい
urlId	string	はい
userIdWS	string	はい
startTime	int64_t	はい
endTime	int64_t	はい

レスポンス

返却: GetEventLog_200_response

例

getEventLog の例

Copy

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

グローバルイベントログを取得

req tenantId urlId userIdWS

パラメータ

名前	型	必須
tenantId	string	はい
urlId	string	はい
userIdWS	string	はい
startTime	int64_t	はい
endTime	int64_t	はい

レスポンス

戻り値: GetEventLog_200_response

例

getGlobalEventLog の例

Copy

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

フィード投稿を作成

パラメータ

名前	型	必須
tenantId	string	はい
createFeedPostParams	CreateFeedPostParams	はい
broadcastId	string	いいえ
isLive	bool	いいえ
doSpamCheck	bool	いいえ
skipDupCheck	bool	いいえ

レスポンス

戻り値: CreateFeedPost_200_response

例

createFeedPost の例

Copy

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

フィード投稿を作成（公開）

パラメータ

名前	型	必須
tenantId	string	はい
createFeedPostParams	CreateFeedPostParams	はい
broadcastId	string	いいえ
sso	string	いいえ

レスポンス

戻り値: CreateFeedPostPublic_200_response

例

createFeedPostPublic の例

Copy

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

フィード投稿を削除（公開）

パラメータ

名前	型	必須
tenantId	string	はい
postId	string	はい
broadcastId	string	いいえ
sso	string	いいえ

レスポンス

戻り値: DeleteFeedPostPublic_200_response

例

deleteFeedPostPublic の例

Copy

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

フィード投稿一覧を取得

パラメータ

名前	型	必須
tenantId	string	はい
afterId	string	いいえ
limit	int32_t	いいえ
tags	vector<string	いいえ

レスポンス

戻り値: GetFeedPosts_200_response

例

getFeedPosts の例

Copy

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

フィード投稿一覧を取得（公開）

req tenantId afterId

パラメータ

名前	型	必須
tenantId	string	はい
afterId	string	いいえ
limit	int32_t	いいえ
tags	vector<string	いいえ
sso	string	いいえ
isCrawler	bool	いいえ
includeUserInfo	bool	いいえ

レスポンス

戻り値: GetFeedPostsPublic_200_response

例

getFeedPostsPublic の例

Copy

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

フィード投稿の統計を取得

パラメータ

名前	型	必須
tenantId	string	はい
postIds	vector<string	はい
sso	string	いいえ

レスポンス

戻り値: GetFeedPostsStats_200_response

例

getFeedPostsStats の例

Copy

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

ユーザーのリアクションを取得（公開）

パラメータ

名前	型	必須
tenantId	string	はい
postIds	vector<string	いいえ
sso	string	いいえ

レスポンス

戻り値: GetUserReactsPublic_200_response

例

getUserReactsPublic の例

Copy

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

フィード投稿にリアクションする（公開）

パラメータ

名前	Type	必須
tenantId	string	はい
postId	string	はい
reactBodyParams	ReactBodyParams	はい
isUndo	bool	いいえ
broadcastId	string	いいえ
sso	string	いいえ

レスポンス

戻り値: ReactFeedPostPublic_200_response

例

reactFeedPostPublic の例

Copy

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

フィード投稿を更新

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
feedPost	FeedPost	はい

レスポンス

戻り値: FlagCommentPublic_200_response

例

updateFeedPost の例

Copy

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

フィード投稿を更新（公開）

パラメータ

名前	型	必須
tenantId	string	はい
postId	string	はい
updateFeedPostParams	UpdateFeedPostParams	はい
broadcastId	string	いいえ
sso	string	いいえ

レスポンス

戻り値: CreateFeedPostPublic_200_response

例

updateFeedPostPublic の例

Copy

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

コメントを通報（公開）

パラメータ

Name	Type	Required
tenantId	string	はい
commentId	string	はい
isFlagged	bool	はい
sso	string	いいえ

レスポンス

返却値: FlagCommentPublic_200_response

例

flagCommentPublic の例

Copy

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

ハッシュタグを追加

パラメータ

名前	型	必須	説明
tenantId	string	任意
createHashTagBody	CreateHashTagBody	任意

レスポンス

戻り値: AddHashTag_200_response

例

addHashTag の例

Copy

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

ハッシュタグを一括追加

パラメータ

名前	型	必須	説明
tenantId	string	任意
bulkCreateHashTagsBody	BulkCreateHashTagsBody	任意

レスポンス

戻り値: AddHashTagsBulk_200_response

例

addHashTagsBulk の例

Copy

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

ハッシュタグを削除

パラメータ

名前	型	必須
tag	string	はい
tenantId	string	いいえ
deleteHashTagRequest	DeleteHashTag_request	いいえ

レスポンス

戻り値: FlagCommentPublic_200_response

例

deleteHashTag の例

Copy

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

ハッシュタグ一覧を取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
page	double	いいえ

レスポンス

返却値: GetHashTags_200_response

例

getHashTags の例

Copy

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

ハッシュタグを部分更新

パラメータ

名前	型	必須
tag	string	はい
tenantId	string	いいえ
updateHashTagBody	UpdateHashTagBody	いいえ

レスポンス

戻り値: PatchHashTag_200_response

例

patchHashTag の例

Copy

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

モデレーターを作成

パラメータ

名前	型	必須	説明
tenantId	string	はい
createModeratorBody	CreateModeratorBody	はい

レスポンス

戻り値: CreateModerator_200_response

例

createModerator の例

Copy

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

モデレーターを削除

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
sendEmail	string	いいえ

レスポンス

戻り値: FlagCommentPublic_200_response

例

deleteModerator の例

Copy

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

モデレーターを取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
id	string	はい

レスポンス

戻り値: GetModerator_200_response

例

getModerator の例

Copy

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

モデレーター一覧を取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
skip	double	いいえ

レスポンス

戻り値: GetModerators_200_response

例

getModerators の例

Copy

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

招待を送信

パラメータ

名前	タイプ	必須
tenantId	string	はい
id	string	はい
fromName	string	はい

レスポンス

返却値: FlagCommentPublic_200_response

例

sendInvite の例

Copy

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

モデレーターを更新

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
updateModeratorBody	UpdateModeratorBody	はい

レスポンス

戻り値: FlagCommentPublic_200_response

例

updateModerator の例

Copy

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

通知カウントを削除

パラメータ

名前	型	必須	説明
tenantId	string	はい
id	string	はい

レスポンス

戻り値: FlagCommentPublic_200_response

例

deleteNotificationCount の例

Copy

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

キャッシュされた通知カウントを取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
id	string	はい

レスポンス

戻り値: GetCachedNotificationCount_200_response

例

getCachedNotificationCount の例

Copy

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

通知カウントを取得

パラメータ

Name	Type	Required
tenantId	string	はい
userId	string	いいえ
urlId	string	いいえ
fromCommentId	string	いいえ
viewed	bool	いいえ
type	string	いいえ

レスポンス

戻り値: GetNotificationCount_200_response

例

getNotificationCount の例

Copy

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

通知一覧を取得

パラメータ

名前	型	必須
tenantId	string	はい
userId	string	いいえ
urlId	string	いいえ
fromCommentId	string	いいえ
viewed	bool	いいえ
type	string	いいえ
skip	double	いいえ

レスポンス

戻り値: GetNotifications_200_response

例

getNotifications の例

Copy

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

通知を更新

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
updateNotificationBody	UpdateNotificationBody	はい
userId	string	いいえ

レスポンス

戻り値: FlagCommentPublic_200_response

例

updateNotification の例

Copy

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

ページを追加

Parameters

Name	Type	Required	Description
tenantId	string	はい
createAPIPageData	CreateAPIPageData	はい

Response

戻り値: AddPageAPIResponse

例

addPage の例

Copy

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

ページを削除

パラメータ

名前	型	必須	説明
tenantId	string	はい
id	string	はい

レスポンス

戻り値: DeletePageAPIResponse

例

deletePage の例

Copy

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

URL ID からページを取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
urlId	string	はい

レスポンス

戻り値: GetPageByURLIdAPIResponse

例

getPageByURLId の例

Copy

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

ページ一覧を取得

パラメータ

名前	型	必須	説明
tenantId	string	はい

レスポンス

戻り値: GetPagesAPIResponse

例

getPages の例

Copy

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

ページを部分更新

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
updateAPIPageData	UpdateAPIPageData	はい

レスポンス

戻り値: PatchPageAPIResponse

例

patchPageの例

Copy

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

保留中のWebhookイベントを削除

パラメータ

名前	型	必須	説明
tenantId	string	はい
id	string	はい

レスポンス

戻り値: FlagCommentPublic_200_response

例

deletePendingWebhookEvent の例

Copy

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

保留中のWebhookイベント数を取得

パラメータ

名前	型	必須
tenantId	string	はい
commentId	string	いいえ
externalId	string	いいえ
eventType	string	いいえ
type	string	いいえ
domain	string	いいえ
attemptCountGT	double	いいえ

レスポンス

戻り値: GetPendingWebhookEventCount_200_response

例

getPendingWebhookEventCount の例

Copy

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

保留中のWebhookイベントを取得

パラメータ

名前	型	必須
tenantId	string	はい
commentId	string	いいえ
externalId	string	いいえ
eventType	string	いいえ
type	string	いいえ
domain	string	いいえ
attemptCountGT	double	いいえ
skip	double	いいえ

レスポンス

戻り値: GetPendingWebhookEvents_200_response

例

getPendingWebhookEvents の例

Copy

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

質問設定を作成

パラメータ

名前	型	必須	説明
tenantId	string	はい
createQuestionConfigBody	CreateQuestionConfigBody	はい

レスポンス

返却: CreateQuestionConfig_200_response

例

createQuestionConfig の例

Copy

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

質問設定を削除

パラメータ

名前	型	必須	説明
tenantId	string	はい
id	string	はい

レスポンス

戻り値: FlagCommentPublic_200_response

例

deleteQuestionConfig の例

Copy

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

質問設定を取得

パラメータ

名前	型	必須	説明
tenantId	string	Yes
id	string	Yes

レスポンス

戻り値: GetQuestionConfig_200_response

例

getQuestionConfig の例

Copy

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

質問設定一覧を取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
skip	double	いいえ

レスポンス

戻り値: GetQuestionConfigs_200_response

例

getQuestionConfigs の例

Copy

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

質問設定を更新

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
updateQuestionConfigBody	UpdateQuestionConfigBody	はい

レスポンス

戻り値: FlagCommentPublic_200_response

例

updateQuestionConfig の例

Copy

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

質問結果を作成

パラメータ

名前	型	必須	説明
tenantId	string	はい
createQuestionResultBody	CreateQuestionResultBody	はい

レスポンス

戻り値: CreateQuestionResult_200_response

例

createQuestionResult の例

Copy

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

質問結果を削除

パラメータ

名前	型	必須	説明
tenantId	string	はい
id	string	はい

レスポンス

戻り値: FlagCommentPublic_200_response

例

deleteQuestionResult の例

Copy

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

質問結果を取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
id	string	はい

レスポンス

戻り値: GetQuestionResult_200_response

例

getQuestionResult の例

Copy

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

質問結果一覧を取得

パラメータ

名前	型	必須
tenantId	string	Yes
urlId	string	No
userId	string	No
startDate	string	No
questionId	string	No
questionIds	string	No
skip	double	No

レスポンス

戻り値: GetQuestionResults_200_response

例

getQuestionResults の例

Copy

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

質問結果を更新

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
updateQuestionResultBody	UpdateQuestionResultBody	はい

レスポンス

戻り値: FlagCommentPublic_200_response

例

updateQuestionResult の例

Copy

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

質問結果を集計

パラメータ

名前	型	必須
tenantId	string	はい
questionId	string	いいえ
questionIds	vector<string	いいえ
urlId	string	いいえ
timeBucket	AggregateTimeBucket	いいえ
startDate	datetime	いいえ
forceRecalculate	bool	いいえ

レスポンス

返却: AggregateQuestionResults_200_response

例

aggregateQuestionResults の例

Copy

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

質問結果を一括集計

パラメータ

名前	型	必須
tenantId	string	はい
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	はい
forceRecalculate	bool	いいえ

レスポンス

戻り値: BulkAggregateQuestionResults_200_response

例

bulkAggregateQuestionResults の例

Copy

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

コメントと質問結果を結合

パラメータ

名前	型	必須
tenantId	string	はい
questionId	string	いいえ
questionIds	vector<string	いいえ
urlId	string	いいえ
startDate	datetime	いいえ
forceRecalculate	bool	いいえ
minValue	double	いいえ
maxValue	double	いいえ
limit	double	いいえ

レスポンス

戻り値: CombineCommentsWithQuestionResults_200_response

例

combineCommentsWithQuestionResults の例

Copy

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

SSO ユーザーを追加

パラメータ

Name	Type	Required	Description
tenantId	string	はい
createAPISSOUserData	CreateAPISSOUserData	はい

レスポンス

戻り値: AddSSOUserAPIResponse

例

addSSOUser の例

Copy

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

SSO ユーザーを削除

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
deleteComments	bool	いいえ
commentDeleteMode	string	いいえ

レスポンス

戻り値: DeleteSSOUserAPIResponse

例

deleteSSOUser の例

Copy

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

メールアドレスで SSO ユーザーを取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
email	string	はい

レスポンス

戻り値: GetSSOUserByEmailAPIResponse

例

getSSOUserByEmail の例

Copy

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

ID で SSO ユーザーを取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
id	string	はい

レスポンス

戻り値: GetSSOUserByIdAPIResponse

例

getSSOUserById の例

Copy

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

SSO ユーザー一覧を取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
skip	int32_t	いいえ

レスポンス

戻り値: GetSSOUsers_200_response

例

getSSOUsers の例

Copy

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

SSO ユーザーを部分更新

パラメーター

Name	Type	Required
tenantId	string	はい
id	string	はい
updateAPISSOUserData	UpdateAPISSOUserData	はい
updateComments	bool	いいえ

レスポンス

戻り値: PatchSSOUserAPIResponse

例

patchSSOUser の例

Copy

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

SSO ユーザーを更新（置換）

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
updateAPISSOUserData	UpdateAPISSOUserData	はい
updateComments	bool	いいえ

レスポンス

戻り値: PutSSOUserAPIResponse

例

putSSOUser の例

Copy

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

サブスクリプションを作成

パラメータ

Name	Type	必須	説明
tenantId	string	はい
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	はい

レスポンス

戻り値: CreateSubscriptionAPIResponse

例

createSubscription の例

Copy

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

サブスクリプションを削除

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
userId	string	いいえ

レスポンス

戻り値: DeleteSubscriptionAPIResponse

例

deleteSubscription の例

Copy

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

サブスクリプション一覧を取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
userId	string	いいえ

レスポンス

返却: GetSubscriptionsAPIResponse

例

getSubscriptions の例

Copy

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

サブスクリプションを更新

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	はい
userId	string	いいえ

レスポンス

戻り値: UpdateSubscriptionAPIResponse

例

updateSubscription の例

Copy

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

テナントの日次使用量を取得

パラメータ

名前	型	必須
tenantId	string	Yes
yearNumber	double	No
monthNumber	double	No
dayNumber	double	No
skip	double	No

レスポンス

戻り値: GetTenantDailyUsages_200_response

例

getTenantDailyUsages の例

Copy

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

テナントパッケージを作成

パラメータ

名前	型	必須	説明
tenantId	string	はい
createTenantPackageBody	CreateTenantPackageBody	はい

レスポンス

返却: CreateTenantPackage_200_response

例

createTenantPackage の例

Copy

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

テナントパッケージを削除

パラメータ

名前	型	必須	説明
tenantId	string	はい
id	string	はい

レスポンス

戻り値: FlagCommentPublic_200_response

例

deleteTenantPackage の例

Copy

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

テナントパッケージを取得

パラメータ

Name	Type	Required	Description
tenantId	string	はい
id	string	はい

レスポンス

戻り値: GetTenantPackage_200_response

例

getTenantPackage の例

Copy

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

テナントパッケージ一覧を取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
skip	double	いいえ

レスポンス

戻り値: GetTenantPackages_200_response

例

getTenantPackages の例

Copy

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

テナントパッケージを置換

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
replaceTenantPackageBody	ReplaceTenantPackageBody	はい

レスポンス

返却値: FlagCommentPublic_200_response

例

replaceTenantPackage の例

Copy

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

テナントパッケージを更新

パラメータ

Name	Type	Required
tenantId	string	はい
id	string	はい
updateTenantPackageBody	UpdateTenantPackageBody	はい

レスポンス

戻り値: FlagCommentPublic_200_response

例

updateTenantPackage の例

Copy

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

テナントユーザーを作成

パラメータ

名前	型	必須	説明
tenantId	string	はい
createTenantUserBody	CreateTenantUserBody	はい

レスポンス

戻り値: CreateTenantUser_200_response

例

createTenantUser の例

Copy

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

テナントユーザーを削除

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
deleteComments	string	いいえ
commentDeleteMode	string	いいえ

レスポンス

戻り値: FlagCommentPublic_200_response

例

deleteTenantUser の例

Copy

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

テナントユーザーを取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
id	string	はい

レスポンス

戻り値: GetTenantUser_200_response

例

getTenantUser の例

Copy

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

テナントユーザー一覧を取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
skip	double	いいえ

レスポンス

戻り値: GetTenantUsers_200_response

例

getTenantUsers の例

Copy

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

テナントユーザーを置換

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
replaceTenantUserBody	ReplaceTenantUserBody	はい
updateComments	string	いいえ

レスポンス

返却: FlagCommentPublic_200_response

例

replaceTenantUser の例

Copy

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

ログインリンクを送信

パラメータ

Name	Type	必須
tenantId	string	はい
id	string	はい
redirectURL	string	いいえ

レスポンス

戻り値: FlagCommentPublic_200_response

例

sendLoginLink の例

Copy

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

テナントユーザーを更新

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
updateTenantUserBody	UpdateTenantUserBody	はい
updateComments	string	いいえ

レスポンス

返却値: FlagCommentPublic_200_response

例

updateTenantUser の例

Copy

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

テナントを作成

パラメータ

Name	Type	必須	説明
tenantId	string	はい
createTenantBody	CreateTenantBody	はい

レスポンス

戻り値: CreateTenant_200_response

例

createTenant の例

Copy

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

テナントを削除

パラメータ

Name	Type	Required
tenantId	string	はい
id	string	はい
sure	string	いいえ

レスポンス

返却値: FlagCommentPublic_200_response

例

deleteTenant の例

Copy

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

テナントを取得

パラメータ

Name	Type	Required	Description
tenantId	string	はい
id	string	はい

レスポンス

戻り値: GetTenant_200_response

例

getTenant の例

Copy

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

テナント一覧を取得

パラメータ

Name	Type	必須
tenantId	string	はい
meta	string	いいえ
skip	double	いいえ

レスポンス

戻り値: GetTenants_200_response

例

getTenants の例

Copy

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

テナントを更新

パラメータ

Name	Type	Required
tenantId	string	はい
id	string	はい
updateTenantBody	UpdateTenantBody	はい

レスポンス

戻り値: FlagCommentPublic_200_response

例

updateTenant の例

Copy

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

チケットの状態を変更

パラメータ

名前	型	必須
tenantId	string	はい
userId	string	はい
id	string	はい
changeTicketStateBody	ChangeTicketStateBody	はい

レスポンス

戻り値: ChangeTicketState_200_response

例

changeTicketState の例

Copy

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

チケットを作成

パラメータ

名前	型	必須
tenantId	string	はい
userId	string	はい
createTicketBody	CreateTicketBody	はい

レスポンス

戻り値: CreateTicket_200_response

例

createTicket の例

Copy

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

チケットを取得

パラメータ

Name	Type	Required
tenantId	string	はい
id	string	はい
userId	string	いいえ

レスポンス

返却: GetTicket_200_response

例

getTicket の例

Copy

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

チケット一覧を取得

パラメータ

名前	型	必須
tenantId	string	はい
userId	string	いいえ
state	double	いいえ
skip	double	いいえ
limit	double	いいえ

レスポンス

戻り値: GetTickets_200_response

例

getTickets の例

Copy

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

画像をアップロード

画像のアップロードとリサイズ

パラメータ

名前	型	必須
tenantId	string	Yes
file	HttpContent	Yes
sizePreset	SizePreset	No
urlId	string	No

レスポンス

戻り値: UploadImageResponse

例

uploadImage の例

Copy

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

ID でユーザーバッジ進捗を取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
id	string	はい

レスポンス

戻り値: GetUserBadgeProgressById_200_response

例

getUserBadgeProgressById の例

Copy

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

ユーザーID でユーザーバッジ進捗を取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
userId	string	はい

レスポンス

戻り値: GetUserBadgeProgressById_200_response

例

getUserBadgeProgressByUserId の例

Copy

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

ユーザーバッジ進捗一覧を取得

パラメータ

名前	型	必須
tenantId	string	はい
userId	string	いいえ
limit	double	いいえ
skip	double	いいえ

レスポンス

戻り値: GetUserBadgeProgressList_200_response

例

getUserBadgeProgressList Example

Copy

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

ユーザーバッジを作成

パラメータ

名前	型	必須	説明
tenantId	string	はい
createUserBadgeParams	CreateUserBadgeParams	はい

レスポンス

戻り値: CreateUserBadge_200_response

例

createUserBadge の例

Copy

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

ユーザーバッジを削除

パラメータ

名前	型	必須	説明
tenantId	string	はい
id	string	はい

レスポンス

戻り値: UpdateUserBadge_200_response

例

deleteUserBadge の例

Copy

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

ユーザーバッジを取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
id	string	はい

レスポンス

戻り値: GetUserBadge_200_response

例

getUserBadge の例

Copy

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

ユーザーバッジ一覧を取得

パラメータ

名前	型	必須
tenantId	string	はい
userId	string	いいえ
badgeId	string	いいえ
type	double	いいえ
displayedOnComments	bool	いいえ
limit	double	いいえ
skip	double	いいえ

レスポンス

戻り値: GetUserBadges_200_response

例

getUserBadges の例

Copy

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

ユーザーバッジを更新

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
updateUserBadgeParams	UpdateUserBadgeParams	はい

レスポンス

戻り値: UpdateUserBadge_200_response

例

updateUserBadge の例

Copy

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

ユーザーの通知カウントを取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
sso	string	いいえ

レスポンス

戻り値: GetUserNotificationCount_200_response

例

getUserNotificationCount の例

Copy

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

ユーザーの通知を取得

パラメータ

Name	型	必須
tenantId	string	はい
pageSize	int32_t	いいえ
afterId	string	いいえ
includeContext	bool	いいえ
afterCreatedAt	int64_t	いいえ
unreadOnly	bool	いいえ
dmOnly	bool	いいえ
noDm	bool	いいえ
includeTranslations	bool	いいえ
sso	string	いいえ

レスポンス

戻り値: GetUserNotifications_200_response

例

getUserNotifications の例

Copy

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

ユーザーの通知カウントをリセット

パラメータ

名前	型	必須	説明
tenantId	string	はい
sso	string	いいえ

レスポンス

戻り値: ResetUserNotifications_200_response

例

resetUserNotificationCount の例

Copy

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

ユーザー通知をリセット

パラメータ

名前	型	必須
tenantId	string	はい
afterId	string	いいえ
afterCreatedAt	int64_t	いいえ
unreadOnly	bool	いいえ
dmOnly	bool	いいえ
noDm	bool	いいえ
sso	string	いいえ

レスポンス

戻り値: ResetUserNotifications_200_response

例

resetUserNotifications の例

Copy

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

ユーザーのコメント購読ステータスを更新

特定のコメントに対する通知を有効または無効にします。

パラメータ

名前	型	必須
tenantId	string	必須
notificationId	string	必須
optedInOrOut	string	必須
commentId	string	必須
sso	string	任意

レスポンス

戻り値: UpdateUserNotificationStatus_200_response

例

updateUserNotificationCommentSubscriptionStatus の例

Copy

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

ユーザーのページ購読ステータスを更新

ページの通知を有効化または無効化します。ユーザーがページを購読している場合、通知は作成され新しいルートコメントに対して、また

パラメータ

名前	型	必須
tenantId	string	はい
urlId	string	はい
url	string	はい
pageTitle	string	はい
subscribedOrUnsubscribed	string	はい
sso	string	いいえ

レスポンス

返却: UpdateUserNotificationStatus_200_response

例

updateUserNotificationPageSubscriptionStatus の例

Copy

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

ユーザー通知のステータスを更新

パラメータ

名前	型	必須
tenantId	string	はい
notificationId	string	はい
newStatus	string	はい
sso	string	いいえ

レスポンス

戻り値: UpdateUserNotificationStatus_200_response

例

updateUserNotificationStatus の例

Copy

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

ユーザーのプレゼンスステータスを取得

パラメータ

Name	Type	Required
tenantId	string	はい
urlIdWS	string	はい
userIds	string	はい

レスポンス

戻り値: GetUserPresenceStatuses_200_response

例

getUserPresenceStatuses の例

Copy

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

ユーザーを検索

パラメータ

名前	型	必須
tenantId	string	はい
urlId	string	はい
usernameStartsWith	string	いいえ
mentionGroupIds	vector<string	いいえ
sso	string	いいえ
searchSection	string	いいえ

レスポンス

戻り値: SearchUsers_200_response

例

searchUsers の例

Copy

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

ユーザーを取得

パラメータ

名前	型	必須	説明
tenantId	string	はい
id	string	はい

レスポンス

戻り値: GetUser_200_response

例

getUser の例

Copy

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

投票を作成

パラメータ

名前	型	必須
tenantId	string	はい
commentId	string	はい
direction	string	はい
userId	string	いいえ
anonUserId	string	いいえ

レスポンス

戻り値: VoteComment_200_response

例

createVote の例

Copy

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

投票を削除

パラメータ

名前	型	必須
tenantId	string	はい
id	string	はい
editKey	string	いいえ

レスポンス

戻り値: DeleteCommentVote_200_response

例

deleteVote の例

Copy

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

投票一覧を取得

パラメータ

Name	Type	Required	Description
tenantId	string	はい
urlId	string	はい

レスポンス

戻り値: GetVotes_200_response

例

getVotes の例

Copy

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

ユーザーの投票を取得

パラメータ

Name	Type	Required
tenantId	string	はい
urlId	string	はい
userId	string	いいえ
anonUserId	string	いいえ

レスポンス

戻り値: GetVotesForUser_200_response

例

getVotesForUser の例

Copy

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

ヘルプが必要ですか？

C++ SDK に関して問題が発生した場合やご質問がある場合は、次のいずれかを行ってください：

貢献

ご貢献は歓迎します！貢献のガイドラインについてはGitHubリポジトリをご覧ください。

言語 🇯🇵 日本語

ドキュメント

はじめに

API リファレンス

使用方法

集計

監査ログ

コメントからのブロック

ブロックされたコメントの確認

コメント

ドメイン設定

メールテンプレート

イベントログ

フィード投稿

コメントの通報

ハッシュタグ

モデレーター

通知カウント

通知

ページ

保留中のWebhookイベント

質問設定

質問結果

質問結果の集計

SSO ユーザー

サブスクリプション

テナント日次使用量

テナントパッケージ

テナントユーザー

テナント

チケット

画像アップロード

ユーザーバッジ進捗

ユーザーバッジ

ユーザー通知

ユーザープレゼンスステータス

ユーザー検索

ユーザー

投票

FastComments の C++ SDK

リポジトリ

要件

インストール

依存関係のインストール

ソースからのビルド

インストール

ライブラリの内容

公開 API と保護された API

クイックスタート

認証された API の使用 (DefaultAPI)

公開 API の使用 (PublicAPI)

よくある問題

API 呼び出し: 同期と非同期

.get() を使った同期呼び出し

.then() を使った非同期呼び出し

同期と非同期の選択

注意事項

ブロードキャストID

SSO (Single Sign-On)

SSO の使用方法

シンプル SSO

セキュア SSO

fastcomments のドキュメント

APIエンドポイントのドキュメント

モデルのドキュメント

集計

パラメータ

レスポンス

例

監査ログを取得

パラメータ

レスポンス

例

コメントでブロック（公開）

パラメータ

レスポンス

例

コメントのブロック解除（公開）

パラメータ

レスポンス

`.get()` を使った同期呼び出し

`.then()` を使った非同期呼び出し