FastComments SDK ב‑C++

זהו ה-SDK הרשמי ב-C++ עבור FastComments.

ה-SDK הרשמי ב-C++ עבור ה-API של FastComments

מאגר

סוכני קידוד AI

תן לסוכן הקידוד שלך את ההקשר של FastComments שהוא צריך - וידג'טים, תצורה, Secure SSO, ה‑REST API, וה‑SDKs:

npx skills add fastcomments/skills

עובד עם Claude Code, Codex, Cursor, Copilot, Gemini, וכל סוכן אחר שה-skills CLI תומך בו.

דרישות

C++17 או מאוחר יותר
CMake 3.14 או מאוחר יותר
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (יורד אוטומטית לצורך בדיקות)

התקנה

התקנת תלותים

sudo apt install libcpprest-dev libboost-all-dev

בנייה ממקור

mkdir build
cd build
cmake ..
make

התקנה

sudo make install

תכולת הספרייה

ספרייה זו מכילה את לקוח ה‑API שנוצר ואת כלי ה‑SSO כדי להקל על העבודה עם ה‑API.

תיעוד ספריית לקוח API

API ציבוריים מול מאובטחים

עבור לקוח ה‑API, קיימות שלוש מחלקות, DefaultApi, PublicApi, ו‑ModerationApi. ה‑DefaultApi מכילה שיטות הדורשות את מפתח ה‑API שלך, ו‑PublicApi מכילה שיטות שניתן לבצע ישירות מדפדפן/מכשיר נייד/וכו׳ ללא אימות. ה‑ModerationApi מספקת חבילת רחבה של API מודרציה בזמן אמת ומהירה. כל שיטה של ModerationApi מקבלת פרמטר sso ויכולה לאמת באמצעות SSO או באמצעות עוגיית סשן של FastComments.com.

התחלה מהירה

שימוש ב-API מאומתים (DefaultAPI)

חשוב:

עליך להגדיר את כתובת הבסיס (המחולל cpp-restsdk אינו קורא אותה ממפרט ה-OpenAPI)
עליך להגדיר את מפתח ה-API שלך ב-ApiClient לפני ביצוע בקשות מאומתות. אם לא תעשה זאת, הבקשות יכשלו עם שגיאת 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>();

    // נדרש: הגדר את כתובת הבסיס (בחר את האזור שלך)
    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>();

    // נדרש: הגדר את כתובת הבסיס
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

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

    // בצע קריאות API ציבוריות
    return 0;
}

שימוש ב-API של מודרציה (ModerationApi)

ModerationApi מחזק את לוח המחוונים של המודרטור. כל שיטה מקבלת פרמטר sso כך שהקריאה מתבצעת בשם מודרטור שמאומת באמצעות SSO (ראו את סעיף ה-SSO למטה כיצד ליצור טוקן):

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

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

    // נדרש: הגדר את כתובת הבסיס
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

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

    // העבר את טוקן ה-SSO של המודרטור כדי לאמת את הקריאה
    auto ssoToken = utility::conversions::to_string_t("YOUR_MODERATOR_SSO_TOKEN");

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

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

    return 0;
}

בעיות נפוצות

שגיאת "URI must contain a hostname": ודא שאתה קורא ל-config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) לפני יצירת ApiClient. המחולל cpp-restsdk אינו קורא אוטומטית את כתובת השרת ממפרט ה-OpenAPI.
שגיאת 401 "missing-api-key": ודא שאתה קורא ל-config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) לפני יצירת המופע של DefaultAPI.
מחלקת API לא נכונה: השתמש ב-DefaultApi לבקשות מאומתות בצד השרת, ב-PublicApi לבקשות בצד הלקוח/ציבוריות, וב-ModerationApi לבקשות לוח המחוונים של המודרטור (מאומתות באמצעות טוקן SSO של מודרטור).

ביצוע קריאות API: סינכרוני מול אסינכרוני

כל שיטות ה‑API ב‑SDK הזה מחזירות pplx::task<std::shared_ptr<ResponseType>> מ‑C++ REST SDK. זה נותן לך גמישות באופן שבו אתה מתמודד עם תגובות API.

Synchronous Calls with `.get()`

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

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

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

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

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

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

Asynchronous Calls with `.then()`

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

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

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

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

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

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

Choosing Between Synchronous and Asynchronous

The choice depends on your runtime environment and application architecture:

.get() (Synchronous blocking)

Blocks the calling thread until the HTTP request completes
Simpler code flow, easier to reason about
Suitable for dedicated worker threads, batch processing, or command-line tools
Not suitable for event loops, GUI threads, or single-threaded servers

.then() (Asynchronous non-blocking)

Returns immediately, callback executes when request completes
Does not block the calling thread
Required for event-driven architectures, GUI applications, or single-threaded event loops
Allows chaining multiple operations
More complex control flow

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

הערות

Broadcast Ids

תראה שעליך להעביר broadcastId בחלק מהקריאות ל-API. כשאתה מקבל אירועים, תקבל את ה-ID הזה בחזרה, כך תדע להתעלם מהאירוע אם אתה מתכנן ליישם שינויים באופן אופטימיסטי בצד הלקוח (שכנראה תרצה לעשות מכיוון שזה מספק את החוויה הטובה ביותר). העבר כאן UUID. ה-ID צריך להיות מספיק ייחודי כדי שלא יופיע פעמיים בסשן בדפדפן.

SSO (כניסה יחידה)

לדוגמאות SSO, ראה למטה.

שימוש ב‑SSO

SSO פשוט

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

using namespace fastcomments::sso;

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

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

SSO מאובטח

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

using namespace fastcomments::sso;

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

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

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

תיעוד עבור fastcomments

Documentation for API Endpoints

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

Class	Method	HTTP request	Description
DefaultApi	addDomainConfig	POST /api/v1/domain-configs
DefaultApi	addHashTag	POST /api/v1/hash-tags
DefaultApi	addHashTagsBulk	POST /api/v1/hash-tags/bulk
DefaultApi	addPage	POST /api/v1/pages
DefaultApi	addSSOUser	POST /api/v1/sso-users
DefaultApi	aggregate	POST /api/v1/aggregate	Aggregates documents by grouping them (if groupBy is provided) and applying multiple operations. Different operations (e.g. sum, countDistinct, avg, etc.) are supported.
DefaultApi	aggregateQuestionResults	GET /api/v1/question-results-aggregation
DefaultApi	blockUserFromComment	POST /api/v1/comments/{id}/block
DefaultApi	bulkAggregateQuestionResults	POST /api/v1/question-results-aggregation/bulk
DefaultApi	changeTicketState	PATCH /api/v1/tickets/{id}/state
DefaultApi	combineCommentsWithQuestionResults	GET /api/v1/question-results-aggregation/combine/comments
DefaultApi	createEmailTemplate	POST /api/v1/email-templates
DefaultApi	createFeedPost	POST /api/v1/feed-posts
DefaultApi	createModerator	POST /api/v1/moderators
DefaultApi	createQuestionConfig	POST /api/v1/question-configs
DefaultApi	createQuestionResult	POST /api/v1/question-results
DefaultApi	createSubscription	POST /api/v1/subscriptions
DefaultApi	createTenant	POST /api/v1/tenants
DefaultApi	createTenantPackage	POST /api/v1/tenant-packages
DefaultApi	createTenantUser	POST /api/v1/tenant-users
DefaultApi	createTicket	POST /api/v1/tickets
DefaultApi	createUserBadge	POST /api/v1/user-badges
DefaultApi	createVote	POST /api/v1/votes
DefaultApi	deleteComment	DELETE /api/v1/comments/{id}
DefaultApi	deleteDomainConfig	DELETE /api/v1/domain-configs/{domain}
DefaultApi	deleteEmailTemplate	DELETE /api/v1/email-templates/{id}
DefaultApi	deleteEmailTemplateRenderError	DELETE /api/v1/email-templates/{id}/render-errors/{errorId}
DefaultApi	deleteHashTag	DELETE /api/v1/hash-tags/{tag}
DefaultApi	deleteModerator	DELETE /api/v1/moderators/{id}
DefaultApi	deleteNotificationCount	DELETE /api/v1/notification-count/{id}
DefaultApi	deletePage	DELETE /api/v1/pages/{id}
DefaultApi	deletePendingWebhookEvent	DELETE /api/v1/pending-webhook-events/{id}
DefaultApi	deleteQuestionConfig	DELETE /api/v1/question-configs/{id}
DefaultApi	deleteQuestionResult	DELETE /api/v1/question-results/{id}
DefaultApi	deleteSSOUser	DELETE /api/v1/sso-users/{id}
DefaultApi	deleteSubscription	DELETE /api/v1/subscriptions/{id}
DefaultApi	deleteTenant	DELETE /api/v1/tenants/{id}
DefaultApi	deleteTenantPackage	DELETE /api/v1/tenant-packages/{id}
DefaultApi	deleteTenantUser	DELETE /api/v1/tenant-users/{id}
DefaultApi	deleteUserBadge	DELETE /api/v1/user-badges/{id}
DefaultApi	deleteVote	DELETE /api/v1/votes/{id}
DefaultApi	flagComment	POST /api/v1/comments/{id}/flag
DefaultApi	getAuditLogs	GET /api/v1/audit-logs
DefaultApi	getCachedNotificationCount	GET /api/v1/notification-count/{id}
DefaultApi	getComment	GET /api/v1/comments/{id}
DefaultApi	getComments	GET /api/v1/comments
DefaultApi	getDomainConfig	GET /api/v1/domain-configs/{domain}
DefaultApi	getDomainConfigs	GET /api/v1/domain-configs
DefaultApi	getEmailTemplate	GET /api/v1/email-templates/{id}
DefaultApi	getEmailTemplateDefinitions	GET /api/v1/email-templates/definitions
DefaultApi	getEmailTemplateRenderErrors	GET /api/v1/email-templates/{id}/render-errors
DefaultApi	getEmailTemplates	GET /api/v1/email-templates
DefaultApi	getFeedPosts	GET /api/v1/feed-posts	req tenantId afterId
DefaultApi	getHashTags	GET /api/v1/hash-tags
DefaultApi	getModerator	GET /api/v1/moderators/{id}
DefaultApi	getModerators	GET /api/v1/moderators
DefaultApi	getNotificationCount	GET /api/v1/notifications/count
DefaultApi	getNotifications	GET /api/v1/notifications
DefaultApi	getPageByURLId	GET /api/v1/pages/by-url-id
DefaultApi	getPages	GET /api/v1/pages
DefaultApi	getPendingWebhookEventCount	GET /api/v1/pending-webhook-events/count
DefaultApi	getPendingWebhookEvents	GET /api/v1/pending-webhook-events
DefaultApi	getQuestionConfig	GET /api/v1/question-configs/{id}
DefaultApi	getQuestionConfigs	GET /api/v1/question-configs
DefaultApi	getQuestionResult	GET /api/v1/question-results/{id}
DefaultApi	getQuestionResults	GET /api/v1/question-results
DefaultApi	getSSOUserByEmail	GET /api/v1/sso-users/by-email/{email}
DefaultApi	getSSOUserById	GET /api/v1/sso-users/by-id/{id}
DefaultApi	getSSOUsers	GET /api/v1/sso-users
DefaultApi	getSubscriptions	GET /api/v1/subscriptions
DefaultApi	getTenant	GET /api/v1/tenants/{id}
DefaultApi	getTenantDailyUsages	GET /api/v1/tenant-daily-usage
DefaultApi	getTenantPackage	GET /api/v1/tenant-packages/{id}
DefaultApi	getTenantPackages	GET /api/v1/tenant-packages
DefaultApi	getTenantUser	GET /api/v1/tenant-users/{id}
DefaultApi	getTenantUsers	GET /api/v1/tenant-users
DefaultApi	getTenants	GET /api/v1/tenants
DefaultApi	getTicket	GET /api/v1/tickets/{id}
DefaultApi	getTickets	GET /api/v1/tickets
DefaultApi	getUser	GET /api/v1/users/{id}
DefaultApi	getUserBadge	GET /api/v1/user-badges/{id}
DefaultApi	getUserBadgeProgressById	GET /api/v1/user-badge-progress/{id}
DefaultApi	getUserBadgeProgressByUserId	GET /api/v1/user-badge-progress/user/{userId}
DefaultApi	getUserBadgeProgressList	GET /api/v1/user-badge-progress
DefaultApi	getUserBadges	GET /api/v1/user-badges
DefaultApi	getVotes	GET /api/v1/votes
DefaultApi	getVotesForUser	GET /api/v1/votes/for-user
DefaultApi	patchDomainConfig	PATCH /api/v1/domain-configs/{domainToUpdate}
DefaultApi	patchHashTag	PATCH /api/v1/hash-tags/{tag}
DefaultApi	patchPage	PATCH /api/v1/pages/{id}
DefaultApi	patchSSOUser	PATCH /api/v1/sso-users/{id}
DefaultApi	putDomainConfig	PUT /api/v1/domain-configs/{domainToUpdate}
DefaultApi	putSSOUser	PUT /api/v1/sso-users/{id}
DefaultApi	renderEmailTemplate	POST /api/v1/email-templates/render
DefaultApi	replaceTenantPackage	PUT /api/v1/tenant-packages/{id}
DefaultApi	replaceTenantUser	PUT /api/v1/tenant-users/{id}
DefaultApi	saveComment	POST /api/v1/comments
DefaultApi	saveCommentsBulk	POST /api/v1/comments/bulk
DefaultApi	sendInvite	POST /api/v1/moderators/{id}/send-invite
DefaultApi	sendLoginLink	POST /api/v1/tenant-users/{id}/send-login-link
DefaultApi	unBlockUserFromComment	POST /api/v1/comments/{id}/un-block
DefaultApi	unFlagComment	POST /api/v1/comments/{id}/un-flag
DefaultApi	updateComment	PATCH /api/v1/comments/{id}
DefaultApi	updateEmailTemplate	PATCH /api/v1/email-templates/{id}
DefaultApi	updateFeedPost	PATCH /api/v1/feed-posts/{id}
DefaultApi	updateModerator	PATCH /api/v1/moderators/{id}
DefaultApi	updateNotification	PATCH /api/v1/notifications/{id}
DefaultApi	updateQuestionConfig	PATCH /api/v1/question-configs/{id}
DefaultApi	updateQuestionResult	PATCH /api/v1/question-results/{id}
DefaultApi	updateSubscription	PATCH /api/v1/subscriptions/{id}
DefaultApi	updateTenant	PATCH /api/v1/tenants/{id}
DefaultApi	updateTenantPackage	PATCH /api/v1/tenant-packages/{id}
DefaultApi	updateTenantUser	PATCH /api/v1/tenant-users/{id}
DefaultApi	updateUserBadge	PUT /api/v1/user-badges/{id}
ModerationApi	deleteModerationVote	DELETE /auth/my-account/moderate-comments/mod_api/vote/{commentId}/{voteId}
ModerationApi	getApiComments	GET /auth/my-account/moderate-comments/mod_api/api/comments
ModerationApi	getApiExportStatus	GET /auth/my-account/moderate-comments/mod_api/api/export/status
ModerationApi	getApiIds	GET /auth/my-account/moderate-comments/mod_api/api/ids
ModerationApi	getBanUsersFromComment	GET /auth/my-account/moderate-comments/mod_api/ban-users/from-comment/{commentId}
ModerationApi	getCommentBanStatus	GET /auth/my-account/moderate-comments/mod_api/get-comment-ban-status/{commentId}
ModerationApi	getCommentChildren	GET /auth/my-account/moderate-comments/mod_api/comment-children/{commentId}
ModerationApi	getCount	GET /auth/my-account/moderate-comments/mod_api/count
ModerationApi	getCounts	GET /auth/my-account/moderate-comments/banned-users/mod_api/counts
ModerationApi	getLogs	GET /auth/my-account/moderate-comments/mod_api/logs/{commentId}
ModerationApi	getManualBadges	GET /auth/my-account/moderate-comments/mod_api/get-manual-badges
ModerationApi	getManualBadgesForUser	GET /auth/my-account/moderate-comments/mod_api/get-manual-badges-for-user
ModerationApi	getModerationComment	GET /auth/my-account/moderate-comments/mod_api/comment/{commentId}
ModerationApi	getModerationCommentText	GET /auth/my-account/moderate-comments/mod_api/get-comment-text/{commentId}
ModerationApi	getPreBanSummary	GET /auth/my-account/moderate-comments/mod_api/pre-ban-summary/{commentId}
ModerationApi	getSearchCommentsSummary	GET /auth/my-account/moderate-comments/mod_api/search/comments/summary
ModerationApi	getSearchPages	GET /auth/my-account/moderate-comments/mod_api/search/pages
ModerationApi	getSearchSites	GET /auth/my-account/moderate-comments/mod_api/search/sites
ModerationApi	getSearchSuggest	GET /auth/my-account/moderate-comments/mod_api/search/suggest
ModerationApi	getSearchUsers	GET /auth/my-account/moderate-comments/mod_api/search/users
ModerationApi	getTrustFactor	GET /auth/my-account/moderate-comments/mod_api/get-trust-factor
ModerationApi	getUserBanPreference	GET /auth/my-account/moderate-comments/mod_api/user-ban-preference
ModerationApi	getUserInternalProfile	GET /auth/my-account/moderate-comments/mod_api/get-user-internal-profile
ModerationApi	postAdjustCommentVotes	POST /auth/my-account/moderate-comments/mod_api/adjust-comment-votes/{commentId}
ModerationApi	postApiExport	POST /auth/my-account/moderate-comments/mod_api/api/export
ModerationApi	postBanUserFromComment	POST /auth/my-account/moderate-comments/mod_api/ban-user/from-comment/{commentId}
ModerationApi	postBanUserUndo	POST /auth/my-account/moderate-comments/mod_api/ban-user/undo
ModerationApi	postBulkPreBanSummary	POST /auth/my-account/moderate-comments/mod_api/bulk-pre-ban-summary
ModerationApi	postCommentsByIds	POST /auth/my-account/moderate-comments/mod_api/comments-by-ids
ModerationApi	postFlagComment	POST /auth/my-account/moderate-comments/mod_api/flag-comment/{commentId}
ModerationApi	postRemoveComment	POST /auth/my-account/moderate-comments/mod_api/remove-comment/{commentId}
ModerationApi	postRestoreDeletedComment	POST /auth/my-account/moderate-comments/mod_api/restore-deleted-comment/{commentId}
ModerationApi	postSetCommentApprovalStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-approval-status/{commentId}
ModerationApi	postSetCommentReviewStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-review-status/{commentId}
ModerationApi	postSetCommentSpamStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-spam-status/{commentId}
ModerationApi	postSetCommentText	POST /auth/my-account/moderate-comments/mod_api/set-comment-text/{commentId}
ModerationApi	postUnFlagComment	POST /auth/my-account/moderate-comments/mod_api/un-flag-comment/{commentId}
ModerationApi	postVote	POST /auth/my-account/moderate-comments/mod_api/vote/{commentId}
ModerationApi	putAwardBadge	PUT /auth/my-account/moderate-comments/mod_api/award-badge
ModerationApi	putCloseThread	PUT /auth/my-account/moderate-comments/mod_api/close-thread
ModerationApi	putRemoveBadge	PUT /auth/my-account/moderate-comments/mod_api/remove-badge
ModerationApi	putReopenThread	PUT /auth/my-account/moderate-comments/mod_api/reopen-thread
ModerationApi	setTrustFactor	PUT /auth/my-account/moderate-comments/mod_api/set-trust-factor
PublicApi	blockFromCommentPublic	POST /block-from-comment/{commentId}
PublicApi	checkedCommentsForBlocked	GET /check-blocked-comments
PublicApi	createCommentPublic	POST /comments/{tenantId}
PublicApi	createFeedPostPublic	POST /feed-posts/{tenantId}
PublicApi	createV1PageReact	POST /page-reacts/v1/likes/{tenantId}
PublicApi	createV2PageReact	POST /page-reacts/v2/{tenantId}
PublicApi	deleteCommentPublic	DELETE /comments/{tenantId}/{commentId}
PublicApi	deleteCommentVote	DELETE /comments/{tenantId}/{commentId}/vote/{voteId}
PublicApi	deleteFeedPostPublic	DELETE /feed-posts/{tenantId}/{postId}
PublicApi	deleteV1PageReact	DELETE /page-reacts/v1/likes/{tenantId}
PublicApi	deleteV2PageReact	DELETE /page-reacts/v2/{tenantId}
PublicApi	flagCommentPublic	POST /flag-comment/{commentId}
PublicApi	getCommentText	GET /comments/{tenantId}/{commentId}/text
PublicApi	getCommentVoteUserNames	GET /comments/{tenantId}/{commentId}/votes
PublicApi	getCommentsForUser	GET /comments-for-user
PublicApi	getCommentsPublic	GET /comments/{tenantId}	req tenantId urlId
PublicApi	getEventLog	GET /event-log/{tenantId}	req tenantId urlId userIdWS
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	req tenantId afterId
PublicApi	getFeedPostsStats	GET /feed-posts/{tenantId}/stats
PublicApi	getGifLarge	GET /gifs/get-large/{tenantId}
PublicApi	getGifsSearch	GET /gifs/search/{tenantId}
PublicApi	getGifsTrending	GET /gifs/trending/{tenantId}
PublicApi	getGlobalEventLog	GET /event-log/global/{tenantId}	req tenantId urlId userIdWS
PublicApi	getOfflineUsers	GET /pages/{tenantId}/users/offline	Past commenters on the page who are NOT currently online. Sorted by displayName. Use this after exhausting /users/online to render a "Members" section. Cursor pagination on commenterName: server walks the partial {tenantId, urlId, commenterName} index from afterName forward via $gt, no $skip cost.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	Currently-online viewers of a page: people whose websocket session is subscribed to the page right now. Returns anonCount + totalCount (room-wide subscribers, including anon viewers we don't enumerate).
PublicApi	getPagesPublic	GET /pages/{tenantId}	List pages for a tenant. Used by the FChat desktop client to populate its room list. Requires `enableFChat` to be true on the resolved custom config for each page. Pages that require SSO are filtered against the requesting user's group access.
PublicApi	getTranslations	GET /translations/{namespace}/{component}
PublicApi	getUserNotificationCount	GET /user-notifications/get-count
PublicApi	getUserNotifications	GET /user-notifications
PublicApi	getUserPresenceStatuses	GET /user-presence-status
PublicApi	getUserReactsPublic	GET /feed-posts/{tenantId}/user-reacts
PublicApi	getUsersInfo	GET /pages/{tenantId}/users/info	Bulk user info for a tenant. Given userIds, return display info from User / SSOUser. Used by the comment widget to enrich users that just appeared via a presence event. No page context: privacy is enforced uniformly (private profiles are masked).
PublicApi	getV1PageLikes	GET /page-reacts/v1/likes/{tenantId}
PublicApi	getV2PageReactUsers	GET /page-reacts/v2/{tenantId}/list
PublicApi	getV2PageReacts	GET /page-reacts/v2/{tenantId}
PublicApi	lockComment	POST /comments/{tenantId}/{commentId}/lock
PublicApi	logoutPublic	PUT /auth/logout
PublicApi	pinComment	POST /comments/{tenantId}/{commentId}/pin
PublicApi	reactFeedPostPublic	POST /feed-posts/{tenantId}/react/{postId}
PublicApi	resetUserNotificationCount	POST /user-notifications/reset-count
PublicApi	resetUserNotifications	POST /user-notifications/reset
PublicApi	searchUsers	GET /user-search/{tenantId}
PublicApi	setCommentText	POST /comments/{tenantId}/{commentId}/update-text
PublicApi	unBlockCommentPublic	DELETE /block-from-comment/{commentId}
PublicApi	unLockComment	POST /comments/{tenantId}/{commentId}/unlock
PublicApi	unPinComment	POST /comments/{tenantId}/{commentId}/unpin
PublicApi	updateFeedPostPublic	PUT /feed-posts/{tenantId}/{postId}
PublicApi	updateUserNotificationCommentSubscriptionStatus	POST /user-notifications/{notificationId}/mark-opted/{optedInOrOut}	Enable or disable notifications for a specific comment.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Enable or disable notifications for a page. When users are subscribed to a page, notifications are created for new root comments, and also
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Upload and resize an image
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Documentation for Models

Documentation for Authorization

api_key

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

אגרגציה

אגמת מסמכים על ידי קיבוץ שלהם (אם מסופק groupBy) והחלת פעולות מרובות. פעולות שונות (למשל sum, countDistinct, avg, וכו') נתמכות.

Parameters

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

Response

מחזיר: AggregateResponse

Example

דוגמת איגוד

Copy

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

קבל יומני ביקורת

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
options	const GetAuditLogsOptions&	Yes

תגובה

מחזיר: GetAuditLogsResponse

דוגמה

דוגמת getAuditLogs

Copy

utility::string_t tenantId = U("my-tenant-123");
GetAuditLogsOptions options;
options.startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-01T00:00:00Z"), utility::datetime::RFC_1123));
options.endDate   = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-31T23:59:59Z"), utility::datetime::RFC_1123));
options.limit     = boost::optional<int>(100);
api->getAuditLogs(tenantId, options).then([](pplx::task<std::shared_ptr<GetAuditLogsResponse>> t) {
    try {
        auto response = t.get();
        // השתמש בתגובה
    } catch (const std::exception& e) {
        // טיפול בשגיאה
    }
});

התנתק ציבורי

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמת logoutPublic

Copy

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

חסימה מהתגובה ציבורית

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
commentId	string	Yes
publicBlockFromCommentParams	PublicBlockFromCommentParams	Yes
sso	string	No

תגובה

מחזיר: BlockSuccess

דוגמה

blockFromCommentPublic דוגמה

Copy

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

ביטול חסימה של תגובה ציבורית

פרמטרים

שם	סוג	הכרחי
tenantId	string	Yes
commentId	string	Yes
publicBlockFromCommentParams	PublicBlockFromCommentParams	Yes
sso	string	No

תגובה

מחזיר: UnblockSuccess

דוגמה

unBlockCommentPublic דוגמה

Copy

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

תגובות נבדקות לחסימה

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
commentIds	string	Yes
sso	string	No

תגובה

מחזיר: CheckBlockedCommentsResponse

דוגמה

checkedCommentsForBlocked דוגמה

Copy

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

חסום משתמש מהתגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
id	string	כן
blockFromCommentParams	BlockFromCommentParams	כן
options	const BlockUserFromCommentOptions&	כן

תגובה

מחזיר: BlockSuccess

דוגמה

דוגמה של blockUserFromComment

Copy

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

צור תגובה ציבורית

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
commentData	CommentData	Yes
options	const CreateCommentPublicOptions&	Yes

תגובה

מחזיר: SaveCommentsResponseWithPresence

דוגמה

דוגמת createCommentPublic

Copy

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

מחק תגובה

פרמטרים

שם	סוג	חובה
tenantId	string	Yes
id	string	Yes
options	const DeleteCommentOptions&	Yes

תגובה

מחזיר: DeleteCommentResult

דוגמה

דוגמה למחיקת תגובה

Copy

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

מחק תגובה ציבורית

פרמטרים

שם	סוג	חובה
tenantId	string	כן
commentId	string	כן
broadcastId	string	כן
options	const DeleteCommentPublicOptions&	כן

תגובה

מחזיר: PublicAPIDeleteCommentResponse

דוגמה

דוגמת deleteCommentPublic

Copy

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

מחק הצבעת תגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
commentId	string	כן
voteId	string	כן
urlId	string	כן
broadcastId	string	כן
options	const DeleteCommentVoteOptions&	כן

תגובה

מחזיר: VoteDeleteResponse

דוגמה

דוגמת deleteCommentVote

Copy

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

סמן תגובה

פרמטרים

שם	סוג	מחויב
tenantId	string	Yes
id	string	Yes
options	const FlagCommentOptions&	Yes

תגובה

מחזיר: FlagCommentResponse

דוגמה

דוגמת flagComment

Copy

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

קבל תגובה

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
id	string	Yes

תגובה

מחזיר: APIGetCommentResponse

דוגמה

דוגמת getComment

Copy

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

קבל תגובות

פרמטרים

שם	סוג	חובה	תיאור
tenantId	string	Yes
options	const GetCommentsOptions&	Yes

תגובה

מחזיר: APIGetCommentsResponse

דוגמה

getComments דוגמה

Copy

utility::string_t tenantId = U("my-tenant-123");
GetCommentsOptions options;
options.page = 1;
options.limit = 50;
options.sort = U("newest");
options.authorEmail = boost::optional<utility::string_t>(U("user@example.com"));
api->getComments(tenantId, options).then([](pplx::task<std::shared_ptr<APIGetCommentsResponse>> task) {
    try {
        auto response = task.get();
        // השתמש בתגובה לפי הצורך
    } catch (const std::exception& e) {
        // טיפול בשגיאה
    }
});

קבל תגובות ציבוריות

req tenantId urlId

פרמטרים

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

תגובה

מחזיר: GetCommentsResponseWithPresence_PublicComment_

דוגמה

דוגמת getCommentsPublic

Copy

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

קבל טקסט תגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
commentId	string	כן
options	const GetCommentTextOptions&	כן

תגובה

מחזיר: PublicAPIGetCommentTextResponse

דוגמה

דוגמת getCommentText

Copy

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

קבל שמות משתמשים שהצביעו על תגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
commentId	string	כן
dir	int32_t	כן
sso	string	לא

תגובה

מחזיר: GetCommentVoteUserNamesSuccessResponse

דוגמה

getCommentVoteUserNames דוגמה

Copy

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

נעל תגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
commentId	string	כן
broadcastId	string	כן
sso	string	לא

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמה של lockComment

Copy

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

הצמד תגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

תגובה

מחזיר: ChangeCommentPinStatusResponse

דוגמה

pinComment דוגמה

Copy

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

שמור תגובה

פרמטרים

שם	סוג	חובה
tenantId	string	כן
createCommentParams	CreateCommentParams	כן
options	const SaveCommentOptions&	כן

תגובה

מחזיר: APISaveCommentResponse

דוגמה

דוגמת saveComment

Copy

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

הגדר טקסט תגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
commentTextUpdateRequest	CommentTextUpdateRequest	Yes
options	const SetCommentTextOptions&	Yes

תגובה

מחזיר: PublicAPISetCommentTextResponse

דוגמה

setCommentText דוגמה

Copy

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

בטל חסימת משתמש מהתגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
id	string	Yes
unBlockFromCommentParams	UnBlockFromCommentParams	Yes
options	const UnBlockUserFromCommentOptions&	Yes

תגובה

מחזיר: UnblockSuccess

דוגמה

unBlockUserFromComment דוגמה

Copy

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

בטל סימון תגובה

פרמטרים

שם	סוג	הכרחי
tenantId	string	Yes
id	string	Yes
options	const UnFlagCommentOptions&	Yes

תגובה

מחזיר: FlagCommentResponse

דוגמה

דוגמת unFlagComment

Copy

auto options = UnFlagCommentOptions{};
options.reason = boost::optional<utility::string_t>(U("Resolved by moderator"));
api->unFlagComment(U("my-tenant-123"), U("comment-456"), options)
    .then([](std::shared_ptr<FlagCommentResponse> response) {
        if (response) {
            auto status = response->status;
            // לעבד את המצב אם נדרש
        }
    })
    .then([](pplx::task<void> previous) {
        try {
            previous.get();
        } catch (const std::exception& e) {
            // טיפול בחריגה
        }
    });

בטל נעילת תגובה

פרמטרים

שם	סוג	חובה
tenantId	string	כן
commentId	string	כן
broadcastId	string	כן
sso	string	לא

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמה של unLockComment

Copy

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

בטל הצמדת תגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
commentId	string	כן
broadcastId	string	כן
sso	string	לא

תגובה

מחזיר: ChangeCommentPinStatusResponse

דוגמה

דוגמת unPinComment

Copy

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

עדכן תגובה

פרמטרים

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updatableCommentParams	UpdatableCommentParams	Yes
options	const UpdateCommentOptions&	Yes

תגובה

מחזיר: APIEmptyResponse

דוגמה

updateComment דוגמה

Copy

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

הצביע על תגובה

Parameters

שם	סוג	נדרש
tenantId	string	כן
commentId	string	כן
urlId	string	כן
broadcastId	string	כן
voteBodyParams	VoteBodyParams	כן
options	const VoteCommentOptions&	כן

Response

מחזיר: VoteResponse

דוגמה

voteComment דוגמה

Copy

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

קבל תגובות למשתמש

פרמטרים

שם	סוג	נדרש	תיאור
options	const GetCommentsForUserOptions&	כן

תגובה

מחזיר: GetCommentsForUserResponse

דוגמה

getCommentsForUser דוגמה

Copy

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

הוסף תצורת תחום

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
addDomainConfigParams	AddDomainConfigParams	כן

תגובה

מחזיר: AddDomainConfigResponse

דוגמה

דוגמת addDomainConfig

Copy

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

מחק תצורת תחום

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
domain	string	כן

תגובה

מחזיר: DeleteDomainConfigResponse

דוגמה

דוגמת deleteDomainConfig

Copy

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

קבל תצורת תחום

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
domain	string	Yes

תגובה

מחזיר: GetDomainConfigResponse

דוגמה

דוגמת getDomainConfig

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domain = U("myblog.example.com");
api->getDomainConfig(tenantId, domain)
    .then([](std::shared_ptr<GetDomainConfigResponse> response) {
        if (!response) return;
        boost::optional<bool> moderationEnabled = response->moderationEnabled;
        boost::optional<std::string> theme = response->theme;
        if (moderationEnabled && *moderationEnabled) {
            // לטפל במודרציה מופעלת
        }
        if (theme) {
            // להשתמש בערך של theme
        }
    })
    .wait();

קבל תצורות תחום

Parameters

Name	Type	Required	Description
tenantId	string	Yes

Response

Returns: GetDomainConfigsResponse

דוגמה

getDomainConfigs דוגמה

Copy

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

עדכן חלקית תצורת תחום

פרמטרים

שם	סוג	חובה
tenantId	string	Yes
domainToUpdate	string	Yes
patchDomainConfigParams	PatchDomainConfigParams	Yes

תגובה

מחזיר: PatchDomainConfigResponse

דוגמה

patchDomainConfig דוגמה

Copy

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

הצב תצורת תחום

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
domainToUpdate	string	כן
updateDomainConfigParams	UpdateDomainConfigParams	כן

תגובה

מחזיר: PutDomainConfigResponse

דוגמה

דוגמת putDomainConfig

Copy

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

צור תבנית אימייל

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
createEmailTemplateBody	CreateEmailTemplateBody	Yes

תגובה

מחזיר: CreateEmailTemplateResponse

דוגמה

createEmailTemplate דוגמה

Copy

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

מחק תבנית אימייל

פרמטרים

שם	סוג	חובה	תיאור
tenantId	string	Yes
id	string	Yes

תגובה

מחזיר: APIEmptyResponse

דוגמה

deleteEmailTemplate דוגמה

Copy

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

מחק שגיאת רינדור של תבנית אימייל

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
id	string	Yes
errorId	string	Yes

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמת deleteEmailTemplateRenderError

Copy

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

קבל תבנית אימייל

Parameters

שם	סוג	נדרש	תיאור
tenantId	string	Yes
id	string	Yes

Response

מחזיר: GetEmailTemplateResponse

Example

דוגמת getEmailTemplate

Copy

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

קבל הגדרות תבנית אימייל

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן

תגובה

מחזיר: GetEmailTemplateDefinitionsResponse

דוגמה

דוגמה של getEmailTemplateDefinitions

Copy

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

קבל שגיאות רינדור של תבנית אימייל

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
id	string	כן
skip	double	לא

תגובה

מחזיר: GetEmailTemplateRenderErrorsResponse

דוגמה

דוגמת getEmailTemplateRenderErrors

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("email-template-789");
boost::optional<double> skip = 20.0;
api->getEmailTemplateRenderErrors(tenantId, id, skip)
    .then([](pplx::task<std::shared_ptr<GetEmailTemplateRenderErrorsResponse>> task) {
        try {
            auto response = task.get();
            // השתמש בתגובה לפי הצורך
        } catch (const std::exception& ex) {
            // טיפול בשגיאה
        }
    });

קבל תבניות אימייל

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
skip	double	No

תגובה

מחזיר: GetEmailTemplatesResponse

דוגמה

דוגמה של getEmailTemplates

Copy

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

רנדר תבנית אימייל

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
renderEmailTemplateBody	RenderEmailTemplateBody	כן
locale	string	לא

תגובה

מחזיר: RenderEmailTemplateResponse

דוגמה

renderEmailTemplate דוגמה

Copy

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

עדכן תבנית אימייל

Parameters

Name	Type	Required
tenantId	string	כן
id	string	כן
updateEmailTemplateBody	UpdateEmailTemplateBody	כן

Response

מחזיר: APIEmptyResponse

Example

דוגמת updateEmailTemplate

Copy

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

קבל יומן אירועים

req tenantId urlId userIdWS

פרמטרים

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
userIdWS	string	Yes
startTime	int64_t	Yes
endTime	int64_t	No

תשובה

מחזיר: GetEventLogResponse

דוגמה

דוגמת getEventLog

Copy

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

קבל יומן אירועים גלובלי

req tenantId urlId userIdWS

פרמטרים

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
userIdWS	string	Yes
startTime	int64_t	Yes
endTime	int64_t	No

תגובה

Returns: GetEventLogResponse

דוגמה

דוגמת getGlobalEventLog

Copy

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

צור פוסט בפיד

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
options	const CreateFeedPostOptions&	Yes

תגובה

מחזיר: CreateFeedPostsResponse

דוגמה

createFeedPost דוגמה

Copy

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

צור פוסט בפיד ציבורי

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
createFeedPostParams	CreateFeedPostParams	כן
options	const CreateFeedPostPublicOptions&	כן

תגובה

מחזיר: CreateFeedPostResponse

דוגמה

דוגמת createFeedPostPublic

Copy

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

מחק פוסט בפיד ציבורי

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
postId	string	Yes
options	const DeleteFeedPostPublicOptions&	Yes

תגובה

מחזיר: DeleteFeedPostPublicResponse

דוגמה

דוגמת deleteFeedPostPublic

Copy

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

קבל פוסטים בפיד

req tenantId afterId

פרמטרים

שם	סוג	חובה	תיאור
tenantId	string	Yes
options	const GetFeedPostsOptions&	Yes

תשובה

מחזיר: GetFeedPostsResponse

דוגמה

דוגמת getFeedPosts

Copy

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

קבל פוסטים בפיד ציבוריים

req tenantId afterId

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
options	const GetFeedPostsPublicOptions&	Yes

תשובה

מחזיר: PublicFeedPostsResponse

דוגמה

דוגמת getFeedPostsPublic

Copy

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

קבל סטטיסטיקות פוסטים בפיד

פרמטרים

שם	סוג	חובה
tenantId	string	כן
postIds	vector<string	כן
sso	string	לא

תגובה

מחזיר: FeedPostsStatsResponse

דוגמה

דוגמת getFeedPostsStats

Copy

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

קבל תגובות משתמש ציבוריות

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
options	const GetUserReactsPublicOptions&	כן

תגובה

מחזיר: UserReactsResponse

דוגמה

getUserReactsPublic דוגמה

Copy

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

הגיב לפוסט בפיד ציבורי

Parameters

שם	סוג	נדרש
tenantId	string	כן
postId	string	כן
reactBodyParams	ReactBodyParams	כן
options	const ReactFeedPostPublicOptions&	כן

Response

מחזיר: ReactFeedPostResponse

Example

דוגמת reactFeedPostPublic

Copy

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

עדכן פוסט בפיד

פרמטרים

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

תגובה

Returns: APIEmptyResponse

דוגמה

דוגמת updateFeedPost

Copy

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

עדכן פוסט בפיד ציבורי

פרמטרים

Name	Type	Required
tenantId	string	Yes
postId	string	Yes
updateFeedPostParams	UpdateFeedPostParams	Yes
options	const UpdateFeedPostPublicOptions&	Yes

תשובה

מחזיר: CreateFeedPostResponse

דוגמה

דוגמת updateFeedPostPublic

Copy

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

סמן תגובה ציבורית

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
commentId	string	כן
isFlagged	bool	כן
sso	string	לא

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמת flagCommentPublic

Copy

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

קבל GIF גדול

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
largeInternalURLSanitized	string	Yes

תגובה

מחזיר: GifGetLargeResponse

דוגמה

דוגמה getGifLarge

Copy

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

חיפוש GIFים

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
search	string	כן
options	const GetGifsSearchOptions&	כן

תגובה

מחזירה: GetGifsSearchResponse

דוגמה

דוגמת getGifsSearch

Copy

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

GIFים פופולריים

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
options	const GetGifsTrendingOptions&	Yes

תגובה

מחזיר: GetGifsTrendingResponse

דוגמה

דוגמה getGifsTrending

Copy

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

הוסף תגית

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
createHashTagBody	CreateHashTagBody	כן

תגובה

מחזיר: CreateHashTagResponse

דוגמה

addHashTag דוגמה

Copy

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

הוסף תגיות במרוכז

פרמטרים

שם	סוג	חובה	תיאור
tenantId	string	כן
bulkCreateHashTagsBody	BulkCreateHashTagsBody	כן

תגובה

מחזיר: BulkCreateHashTagsResponse

דוגמה

addHashTagsBulk דוגמה

Copy

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

מחק תגית

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
tag	string	Yes
deleteHashTagRequestBody	DeleteHashTagRequestBody	Yes

תשובה

מחזיר: APIEmptyResponse

דוגמה

דוגמת deleteHashTag

Copy

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

קבל תגיות

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
page	double	לא

תגובה

מחזיר: GetHashTagsResponse

דוגמה

דוגמת getHashTags

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
boost::optional<double> page = 2.0;
api->getHashTags(tenantId, page).then([](pplx::task<std::shared_ptr<GetHashTagsResponse>> task) {
    try {
        auto resultPtr = task.get();
        auto response = std::make_shared<GetHashTagsResponse>(*resultPtr);
        // השתמש בתגובה
    } catch (const std::exception&) {
        // טיפול בשגיאה
    }
});

עדכן חלקית תגית

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
tag	string	כן
updateHashTagBody	UpdateHashTagBody	כן

תגובה

מחזיר: UpdateHashTagResponse

דוגמה

דוגמת patchHashTag

Copy

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

מחק הצבעת מודרציה

Parameters

שם	סוג	נדרש
tenantId	string	Yes
commentId	string	Yes
voteId	string	Yes
options	const DeleteModerationVoteOptions&	Yes

תגובה

מחזירה: VoteDeleteResponse

דוגמה

דוגמה deleteModerationVote

Copy

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

קבל תגובות API

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
options	const GetApiCommentsOptions&	Yes

תגובה

מחזיר: ModerationAPIGetCommentsResponse

דוגמה

דוגמת getApiComments

Copy

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

קבל סטטוס ייצוא API

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
options	const GetApiExportStatusOptions&	כן

תגובה

מחזיר: ModerationExportStatusResponse

דוגמה

getApiExportStatus דוגמה

Copy

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

קבל מזהי API

פרמטרים

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

תגובה

Returns: ModerationAPIGetCommentIdsResponse

דוגמה

דוגמת getApiIds

Copy

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

קבל משתמשים חסומים מהתגובה

פרמטרים

שם	סוג	חובה
tenantId	string	כן
commentId	string	כן
sso	string	לא

תגובה

מחזיר: GetBannedUsersFromCommentResponse

דוגמה

דוגמת getBanUsersFromComment

Copy

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

קבל סטטוס חסימת תגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
commentId	string	כן
sso	string	לא

תגובה

מחזיר: GetCommentBanStatusResponse

דוגמה

דוגמה getCommentBanStatus

Copy

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

קבל תגובות משניות

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
commentId	string	כן
sso	string	לא

תגובה

מחזיר: ModerationAPIChildCommentsResponse

דוגמה

getCommentChildren דוגמה

Copy

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

קבל ספירה

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
options	const GetCountOptions&	כן

תגובה

מחזיר: ModerationAPICountCommentsResponse

דוגמה

דוגמת getCount

Copy

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

קבל ספירות

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
sso	string	No

תגובה

מחזיר: GetBannedUsersCountResponse

דוגמה

דוגמת getCounts

Copy

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

קבל יומנים

פרמטרים

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

תגובה

מחזיר: ModerationAPIGetLogsResponse

דוגמה

דוגמת getLogs

Copy

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

קבל תגים ידניים

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
sso	string	No

תגובה

מחזיר: GetTenantManualBadgesResponse

דוגמה

דוגמת getManualBadges

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> sso = boost::make_optional(U("user@example.com"));
api->getManualBadges(tenantId, sso)
    .then([](pplx::task<std::shared_ptr<GetTenantManualBadgesResponse>> t) {
        try {
            auto response = t.get();
            // עיבוד תגובה, למשל response->badgeList
        } catch (const std::exception& ex) {
            // טיפול בשגיאה
        }
    });

קבל תגים ידניים למשתמש

פרמטרים

שם	סוג	חובה	תיאור
tenantId	string	Yes
options	const GetManualBadgesForUserOptions&	Yes

תגובה

מחזיר: GetUserManualBadgesResponse

דוגמה

דוגמת getManualBadgesForUser

Copy

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

קבל תגובה למודרציה

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
commentId	string	כן
options	const GetModerationCommentOptions&	כן

תשובה

מחזיר: ModerationAPICommentResponse

דוגמה

getModerationComment דוגמה

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-456");
GetModerationCommentOptions options;
options.includeDeleted = boost::optional<bool>(true);
options.locale = boost::optional<utility::string_t>(utility::conversions::to_string_t("en-US"));
api->getModerationComment(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<ModerationAPICommentResponse>> task) {
        try {
            auto response = task.get();
            // לעבד את התגובה לפי הצורך
        } catch (const std::exception& ex) {
            // טיפול בשגיאה
        }
    });

קבל טקסט תגובה למודרציה

פרמטרים

שם	סוג	חובה
tenantId	string	Yes
commentId	string	Yes
sso	string	No

תשובה

מחזיר: GetCommentTextResponse

דוגמה

דוגמה של getModerationCommentText

Copy

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

קבל סיכום לפני חסימה

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
commentId	string	Yes
options	const GetPreBanSummaryOptions&	Yes

תגובה

מחזיר: PreBanSummary

דוגמה

דוגמת getPreBanSummary

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("cmt-456789");
GetPreBanSummaryOptions options;
options.locale = boost::optional<utility::string_t>{utility::conversions::to_string_t("en-US")};
api->getPreBanSummary(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<PreBanSummary>> t) {
        try {
            auto summary = t.get();
            // עיבוד סיכום
        } catch (const std::exception&) {
            // טיפול בשגיאה
        }
    });

קבל סיכום חיפוש תגובות

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
options	const GetSearchCommentsSummaryOptions&	כן

תגובה

מחזיר: ModerationCommentSearchResponse

דוגמה

דוגמת getSearchCommentsSummary

Copy

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

קבל דפים בחיפוש

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
options	const GetSearchPagesOptions&	כן

תגובה

מחזיר: ModerationPageSearchResponse

דוגמה

getSearchPages דוגמה

Copy

GetSearchPagesOptions options;
options.pageNumber = boost::optional<int>(1);
options.pageSize = boost::optional<int>(50);
options.searchTerm = boost::optional<utility::string_t>(U("spam"));
api->getSearchPages(U("my-tenant-123"), options)
    .then([](pplx::task<std::shared_ptr<ModerationPageSearchResponse>> task) {
        try {
            auto response = task.get();
            // השתמש בתגובה
        } catch (const std::exception& e) {
            // טיפול בשגיאה
        }
    });

קבל אתרים בחיפוש

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
options	const GetSearchSitesOptions&	כן

תגובה

מחזיר: ModerationSiteSearchResponse

דוגמה

דוגמת getSearchSites

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
GetSearchSitesOptions options;
options.query = boost::make_optional(utility::string_t(U("example query")));
options.limit = boost::make_optional(25);
api->getSearchSites(tenantId, options)
   .then([](pplx::task<std::shared_ptr<ModerationSiteSearchResponse>> t) {
       try {
           auto response = t.get();
           auto respPtr = std::make_shared<ModerationSiteSearchResponse>(*response);
           for (const auto& site : respPtr->sites) {
               // לוגיקת עיבוד
           }
       } catch (const std::exception&) {
           // טיפול בשגיאה
       }
   });

קבל הצעות חיפוש

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
options	const GetSearchSuggestOptions&	כן

תגובה

מחזיר: ModerationSuggestResponse

דוגמה

דוגמת getSearchSuggest

Copy

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

קבל משתמשים בחיפוש

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
options	const GetSearchUsersOptions&	כן

תגובה

מחזיר: ModerationUserSearchResponse

דוגמה

דוגמת getSearchUsers

Copy

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

קבל גורם אמון

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
options	const GetTrustFactorOptions&	Yes

תגובה

מחזיר: GetUserTrustFactorResponse

דוגמה

getTrustFactor דוגמה

Copy

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

קבל העדפת חסימת משתמש

פרמטרים

שם	סוג	חובה	תיאור
tenantId	string	Yes
sso	string	No

תשובה

מחזיר: APIModerateGetUserBanPreferencesResponse

דוגמה

דוגמת getUserBanPreference

Copy

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

קבל פרופיל פנימי של משתמש

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
options	const GetUserInternalProfileOptions&	Yes

תגובה

מחזיר: GetUserInternalProfileResponse

דוגמה

דוגמה של getUserInternalProfile

Copy

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

הגבר הצבעות תגובה

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
adjustCommentVotesParams	AdjustCommentVotesParams	Yes
options	const PostAdjustCommentVotesOptions&	Yes

Response

מחזיר: AdjustVotesResponse

Example

דוגמת postAdjustCommentVotes

Copy

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

ייצא API

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
options	const PostApiExportOptions&	כן

תגובה

מחזיר: ModerationExportResponse

דוגמה

postApiExport דוגמה

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
PostApiExportOptions options;
options.format = utility::string_t(U("json"));
options.email = utility::string_t(U("reports@example.com"));
options.startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-01T00:00:00Z")));
options.endDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-31T23:59:59Z")));
api->postApiExport(tenantId, options)
    .then([](std::shared_ptr<ModerationExportResponse> response) {
        if (response) {
            // טיפול בתגובה מוצלחת של הייצוא
        }
    })
    .wait();

חסום משתמש מהתגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
commentId	string	כן
options	const PostBanUserFromCommentOptions&	כן

תגובה

מחזיר: BanUserFromCommentResult

דוגמה

דוגמת postBanUserFromComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("comment-456789");
PostBanUserFromCommentOptions options;
options.reason = boost::optional<utility::string_t>(U("spam"));
options.durationDays = boost::optional<int>(30);
api->postBanUserFromComment(tenantId, commentId, options)
    .then([](std::shared_ptr<BanUserFromCommentResult> result) {
        // טיפול בתוצאה
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* טיפול בשגיאה */ }
    });

בטל חסימת משתמש

פרמטרים

שם	סוג	חובה
tenantId	string	Yes
banUserUndoParams	BanUserUndoParams	Yes
sso	string	No

תגובה

מחזיר: APIEmptyResponse

דוגמה

postBanUserUndo דוגמה

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
BanUserUndoParams banParams;
banParams.userId = utility::string_t(U("user-567"));
banParams.reason = utility::string_t(U("reinstated"));
boost::optional<utility::string_t> sso = utility::string_t(U("sso-token-abc"));
api->postBanUserUndo(tenantId, banParams, sso).then([](std::shared_ptr<APIEmptyResponse> resp){
    // טיפול בהצלחה
});

סיכום חסימה מקבוצתית

Parameters

שם	סוג	דרוש
tenantId	string	כן
bulkPreBanParams	BulkPreBanParams	כן
options	const PostBulkPreBanSummaryOptions&	כן

תגובה

מחזיר: BulkPreBanSummary

דוגמה

postBulkPreBanSummary דוגמה

Copy

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

פרסם תגובות לפי מזהים

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
commentsByIdsParams	CommentsByIdsParams	Yes
sso	string	No

תגובה

מחזיר: ModerationAPIChildCommentsResponse

דוגמה

postCommentsByIds דוגמה

Copy

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

סמן תגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
commentId	string	Yes
options	const PostFlagCommentOptions&	Yes

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמת postFlagComment

Copy

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

הסר תגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
commentId	string	Yes
options	const PostRemoveCommentOptions&	Yes

תגובה

מחזיר: PostRemoveCommentApiResponse

דוגמה

דוגמת postRemoveComment

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto commentId = utility::string_t(U("cmt-456789"));
PostRemoveCommentOptions options;
options.permanent = boost::optional<bool>(true);
api->postRemoveComment(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<PostRemoveCommentApiResponse>> task) {
        try {
            auto response = task.get();
            // עיבוד תגובה
        } catch (const std::exception& ex) {
            // טיפול בשגיאה
        }
    });

שחזר תגובה שנמחקה

פרמטרים

Name	Type	Required
tenantId	string	כן
commentId	string	כן
options	const PostRestoreDeletedCommentOptions&	כן

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמת postRestoreDeletedComment

Copy

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

קבע סטטוס אישור תגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentApprovalStatusOptions&	Yes

תגובה

מחזיר: SetCommentApprovedResponse

דוגמה

דוגמת postSetCommentApprovalStatus

Copy

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

קבע סטטוס ביקורת תגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentReviewStatusOptions&	Yes

תגובה

מחזירה: APIEmptyResponse

דוגמה

דוגמת postSetCommentReviewStatus

Copy

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

קבע סטטוס ספאם לתגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
commentId	string	כן
options	const PostSetCommentSpamStatusOptions&	כן

תגובה

מחזיר: APIEmptyResponse

דוגמה

postSetCommentSpamStatus דוגמה

Copy

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

קבע טקסט תגובה

פרמטרים

שם	סוג	חובה
tenantId	string	Yes
commentId	string	Yes
setCommentTextParams	SetCommentTextParams	Yes
options	const PostSetCommentTextOptions&	Yes

תגובה

מחזיר: SetCommentTextResponse

דוגמה

postSetCommentText דוגמה

Copy

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

בטל סימון תגובה

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
commentId	string	Yes
options	const PostUnFlagCommentOptions&	Yes

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמה של postUnFlagComment

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
PostUnFlagCommentOptions opts;
opts.notifyUser = boost::optional<bool>(true);
api->postUnFlagComment(tenantId, commentId, opts)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // ניתן לבצע עיבוד כאן
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

הצביע

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
commentId	string	כן
options	const PostVoteOptions&	כן

תגובה

מחזיר: VoteResponse

דוגמה

דוגמת postVote

Copy

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

הענק תג

פרמטרים

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

תגובה

מחזיר: AwardUserBadgeResponse

דוגמה

putAwardBadge דוגמה

Copy

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

סגור שרשור

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
urlId	string	Yes
sso	string	No

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמת putCloseThread

Copy

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

הסר תג

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
badgeId	string	Yes
options	const PutRemoveBadgeOptions&	Yes

תגובה

מחזירה: RemoveUserBadgeResponse

דוגמה

דוגמת putRemoveBadge

Copy

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

פתח מחדש שרשור

Parameters

שם	סוג	חובה
tenantId	string	כן
urlId	string	כן
sso	string	לא

Response

מחזיר: APIEmptyResponse

Example

דוגמת putReopenThread

Copy

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

קבע גורם אמון

פרמטרים

שם	סוג	חובה	תיאור
tenantId	string	כן
options	const SetTrustFactorOptions&	כן

תגובה

מחזיר: SetUserTrustFactorResponse

דוגמה

דוגמת setTrustFactor

Copy

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

צור מודרטור

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
createModeratorBody	CreateModeratorBody	Yes

תגובה

מחזיר: CreateModeratorResponse

דוגמה

דוגמת createModerator

Copy

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

מחק מודרטור

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
id	string	Yes
sendEmail	string	No

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמת deleteModerator

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto moderatorId = utility::conversions::to_string_t("mod-456");
boost::optional<utility::string_t> sendEmail = utility::conversions::to_string_t("admin@example.com");
api->deleteModerator(tenantId, moderatorId, sendEmail)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // טיפול בהצלחה
    });

קבל מודרטור

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
id	string	כן

תשובה

מחזיר: GetModeratorResponse

דוגמה

getModerator דוגמה

Copy

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

קבל מודרטורים

פרמטרים

Name	Type	Required	Description
tenantId	string	כן
skip	double	לא

תגובה

מחזיר: GetModeratorsResponse

דוגמה

דוגמת getModerators

Copy

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

שלח הזמנה

פרמטרים

שם	סוג	חובה
tenantId	string	כן
id	string	כן
fromName	string	כן

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמת sendInvite

Copy

boost::optional<utility::string_t> cc = utility::conversions::to_string_t("cc@example.com");
api->sendInvite(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("invitee@example.com"),
    utility::conversions::to_string_t("John Doe")
).then([](std::shared_ptr<APIEmptyResponse> resp) {
    // טיפול בהזמנה מוצלחת
});

עדכן מודרטור

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
id	string	Yes
updateModeratorBody	UpdateModeratorBody	Yes

תגובה

מחזיר: APIEmptyResponse

דוגמה

updateModerator דוגמה

Copy

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

מחק ספירת התראות

פרמטרים

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

תגובה

מחזיר: APIEmptyResponse

דוגמה

deleteNotificationCount דוגמה

Copy

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

קבל ספירת התראות במטמון

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
id	string	כן

תגובה

מחזיר: GetCachedNotificationCountResponse

דוגמה

דוגמה ל‑getCachedNotificationCount

Copy

auto tenantId = boost::optional<utility::string_t>(utility::conversions::to_string_t("my-tenant-123"));
auto userId = boost::optional<utility::string_t>(utility::conversions::to_string_t("user-456"));
api->getCachedNotificationCount(tenantId.value(), userId.value())
    .then([](pplx::task<std::shared_ptr<GetCachedNotificationCountResponse>> task) {
        try {
            auto response = task.get();
            // לעבד תגובה
        } catch (const std::exception&) {
            // טיפול ב‑שגיאה
        }
    });

קבל ספירת התראות

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
options	const GetNotificationCountOptions&	Yes

תגובה

מחזיר: GetNotificationCountResponse

דוגמה

דוגמת getNotificationCount

Copy

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

קבל התראות

פרמטרים

שם	סוג	חובה	תיאור
tenantId	string	כן
options	const GetNotificationsOptions&	כן

תגובה

מחזירה: GetNotificationsResponse

דוגמה

דוגמת getNotifications

Copy

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

עדכן התראה

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
id	string	כן
updateNotificationBody	UpdateNotificationBody	כן
userId	string	לא

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמת updateNotification

Copy

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

צור תגובה לדף V1

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
urlId	string	כן
title	string	לא

תגובה

Returns: CreateV1PageReact

דוגמא

createV1PageReact דוגמא

Copy

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

צור תגובה לדף V2

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
urlId	string	כן
id	string	כן
title	string	לא

תגובה

מחזיר: CreateV1PageReact

דוגמה

createV2PageReact דוגמה

Copy

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

מחק תגובה לדף V1

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
urlId	string	כן

תגובה

מחזיר: CreateV1PageReact

דוגמה

deleteV1PageReact דוגמה

Copy

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

מחק תגובה לדף V2

פרמטרים

Name	Type	Required
tenantId	string	כן
urlId	string	כן
id	string	כן

תגובה

מחזיר: CreateV1PageReact

דוגמה

deleteV2PageReact דוגמה

Copy

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

קבל לייקים לדף V1

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
urlId	string	Yes

תגובה

מחזיר: GetV1PageLikes

דוגמה

דוגמת getV1PageLikes

Copy

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

קבל תגובות לדף V2

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
urlId	string	Yes

תגובה

מחזיר: GetV2PageReacts

דוגמה

דוגמת getV2PageReacts

Copy

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

קבל משתמשי תגובות לדף V2

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
urlId	string	Yes
id	string	Yes

תגובה

מחזיר: GetV2PageReactUsersResponse

דוגמה

דוגמת getV2PageReactUsers

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto urlId = utility::conversions::to_string_t("page-456");
auto id = utility::conversions::to_string_t("react-789");
boost::optional<utility::string_t> maybeFilter;
api->getV2PageReactUsers(tenantId, urlId, id).then([](pplx::task<std::shared_ptr<GetV2PageReactUsersResponse>> task){
    try{
        auto response = task.get();
        // השתמש בתגובה לפי הצורך
    }catch(const std::exception&){
        // טפל בשגיאה
    }
});

הוסף דף

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
createAPIPageData	CreateAPIPageData	כן

תשובה

מחזיר: AddPageAPIResponse

דוגמה

דוגמה של addPage

Copy

auto createData = CreateAPIPageData{};
createData.title = utility::string_t(U("Welcome Page"));
createData.url = utility::string_t(U("https://example.com/welcome"));
createData.description = boost::optional<utility::string_t>(utility::string_t(U("Landing page for new users")));
api->addPage(utility::string_t(U("my-tenant-123")), createData)
    .then([](std::shared_ptr<AddPageAPIResponse> response) {
        if (response && response->success) {
            // טיפול בהוספה מוצלחת
        } else {
            // טיפול בשגיאה
        }
    });

מחק דף

פרמטרים

שם	סוג	חובה	תיאור
tenantId	string	Yes
id	string	Yes

תגובה

מחזיר: DeletePageAPIResponse

דוגמה

deletePage דוגמה

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto pageId   = utility::conversions::to_string_t("page-456");
api->deletePage(tenantId, pageId)
   .then([](pplx::task<std::shared_ptr<DeletePageAPIResponse>> t) {
       try {
           auto response = t.get();
           // לעבד את התגובה לפי הצורך
       } catch (const std::exception& ex) {
           // טיפול בשגיאה
       }
   });

קבל משתמשים לא מקוונים

Past commenters on the page who are NOT currently online. Sorted by displayName.
המגיבים הקודמים בעמוד שאינם מחוברים כעת. ממוין לפי displayName.

Use this after exhausting /users/online to render a "Members" section.
השתמש בזה אחרי שמיצינו את /users/online כדי להציג סעיף "Members".

Cursor pagination on commenterName: server walks the partial {tenantId, urlId, commenterName} index from afterName forward via $gt, no $skip cost.
דפדוף עם סמן על commenterName: השרת נע דרך החלק {tenantId, urlId, commenterName} מהאינדקס אחרי afterName קדימה באמצעות $gt, ללא עלות של $skip.

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
urlId	string	Yes
options	const GetOfflineUsersOptions&	Yes

תגובה

מחזיר: PageUsersOfflineResponse

דוגמה

דוגמת getOfflineUsers

Copy

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

קבל משתמשים מקוונים

צופים מקוונים כרגע של דף: אנשים שהחיבור WebSocket שלהם מנוי לדף ברגע זה.
מחזיר anonCount + totalCount (מנויים ברמת החדר, כולל צופים אנונימיים שאינם נרשמים).

פרמטרים

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

תשובה

מחזיר: PageUsersOnlineResponse

דוגמה

דוגמת getOnlineUsers

Copy

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

קבל דף לפי מזהה URL

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
urlId	string	Yes

תגובה

מחזיר: GetPageByURLIdAPIResponse

דוגמה

דוגמת getPageByURLId

Copy

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

קבל דפים

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן

תגובה

מחזיר: GetPagesAPIResponse

דוגמה

דוגמת getPages

Copy

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

קבל דפים ציבוריים

List pages for a tenant. Used by the FChat desktop client to populate its room list. Requires enableFChat to be true on the resolved custom config for each page. Pages that require SSO are filtered against the requesting user's group access.

Parameters

שם	סוג	נדרש	תיאור
tenantId	string	כן
options	const GetPagesPublicOptions&	כן

Response

מחזיר: GetPublicPagesResponse

Example

דוגמת getPagesPublic

Copy

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

קבל מידע משתמש

מידע משתמשים במצב גורף עבור שוכר. בהתבסס על userIds, מחזיר מידע תצוגה מ‑User / SSOUser. משמש את וידג׳ט ההערות להעשיר משתמשים שהופיעו זה עתה באמצעות אירוע נוכחות. אין הקשר דף: הפרטיות נאכפת באופן אחיד (פרופילים פרטיים מוסתרים).

Parameters

שם	סוג	נדרש	תיאור
tenantId	string	כן
ids	string	כן

Response

מחזיר: PageUsersInfoResponse

דוגמה

דוגמת getUsersInfo

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t ids = U("alice@example.com,bob@example.com");
boost::optional<utility::string_t> locale = boost::make_optional(U("en-US"));
api->getUsersInfo(tenantId, ids).then([](pplx::task<std::shared_ptr<PageUsersInfoResponse>> t){
    try{
        auto response = t.get();
        // עיבוד תגובה
    }catch(const std::exception&){
        // טיפול בשגיאה
    }
});

עדכן חלקית דף

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
id	string	כן
updateAPIPageData	UpdateAPIPageData	כן

תגובה

מחזיר: PatchPageAPIResponse

דוגמה

patchPage דוגמה

Copy

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

מחק אירוע ווב‑הוק ממתין

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
id	string	כן

תגובה

מחזירה: APIEmptyResponse

דוגמה

דוגמת deletePendingWebhookEvent

Copy

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

קבל ספירת אירועי ווב‑הוק ממתינים

פרמטרים

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

תגובה

מחזיר: GetPendingWebhookEventCountResponse

דוגמה

דוגמת getPendingWebhookEventCount

Copy

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

קבל אירועי ווב‑הוק ממתינים

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
options	const GetPendingWebhookEventsOptions&	Yes

תשובה

מחזירה: GetPendingWebhookEventsResponse

דוגמה

דוגמה getPendingWebhookEvents

Copy

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

צור תצורת שאלה

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
createQuestionConfigBody	CreateQuestionConfigBody	כן

תגובה

מחזיר: CreateQuestionConfigResponse

דוגמה

createQuestionConfig דוגמה

Copy

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

מחק תצורת שאלה

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
id	string	כן

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמה למחיקת תצורת שאלה

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto configId = utility::conversions::to_string_t("question-config-456");
api->deleteQuestionConfig(tenantId, configId)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // טיפול במחיקה מוצלחת
    })
    .then([](pplx::task<void> t) {
        try {
            t.get();
        } catch (const std::exception&) {
            // טיפול בשגיאה
        }
    });

קבל תצורת שאלה

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
id	string	כן

תגובה

מחזיר: GetQuestionConfigResponse

דוגמה

דוגמת getQuestionConfig

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto questionId = utility::conversions::to_string_t("question-456");
api->getQuestionConfig(tenantId, questionId)
    .then([](pplx::task<std::shared_ptr<GetQuestionConfigResponse>> task) {
        try {
            auto response = task.get();
            // השתמש בתגובה לפי הצורך
        } catch (const std::exception&) {
            // טיפול בשגיאה
        }
    });

קבל תצורות שאלות

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
skip	double	לא

תשובה

מחזיר: GetQuestionConfigsResponse

דוגמה

דוגמת getQuestionConfigs

Copy

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

עדכן תצורת שאלה

פרמטרים

שם	סוג	חובה
tenantId	string	Yes
id	string	Yes
updateQuestionConfigBody	UpdateQuestionConfigBody	Yes

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמת updateQuestionConfig

Copy

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

צור תוצאה לשאלה

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
createQuestionResultBody	CreateQuestionResultBody	כן

תגובה

מחזיר: CreateQuestionResultResponse

דוגמה

createQuestionResult דוגמה

Copy

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

מחק תוצאה לשאלה

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
id	string	כן

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמה של deleteQuestionResult

Copy

boost::optional<utility::string_t> optTenant = utility::conversions::to_string_t( "my-tenant-123" );
utility::string_t questionId = utility::conversions::to_string_t( "question-456" );
if ( optTenant )
{
    api->deleteQuestionResult( *optTenant, questionId )
        .then( []( pplx::task<std::shared_ptr<APIEmptyResponse>> t )
        {
            try
            {
                auto resp = t.get();
                // טיפול בהצלחה
            }
            catch ( const std::exception& e )
            {
                // טיפול בשגיאה
            }
        } );
}

קבל תוצאה לשאלה

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
id	string	כן

תגובה

מחזיר: GetQuestionResultResponse

דוגמה

getQuestionResult דוגמה

Copy

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

קבל תוצאות לשאלות

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
options	const GetQuestionResultsOptions&	Yes

תשובה

מחזיר: GetQuestionResultsResponse

דוגמה

דוגמה getQuestionResults

Copy

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

עדכן תוצאה לשאלה

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
id	string	כן
updateQuestionResultBody	UpdateQuestionResultBody	כן

תגובה

מחזיר: APIEmptyResponse

דוגמה

updateQuestionResult דוגמה

Copy

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

אגרגציית תוצאות שאלות

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
options	const AggregateQuestionResultsOptions&	Yes

תגובה

מחזיר: AggregateQuestionResultsResponse

דוגמה

דוגמת aggregateQuestionResults

Copy

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

אגרגציית תוצאות שאלות במרוכז

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Yes
forceRecalculate	bool	No

תשובה

מחזיר: BulkAggregateQuestionResultsResponse

דוגמה

bulkAggregateQuestionResults דוגמה

Copy

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

שילוב תגובות עם תוצאות שאלות

פרמטרים

שם	סוג	חובה	תיאור
tenantId	string	Yes
options	const CombineCommentsWithQuestionResultsOptions&	Yes

תגובה

מחזיר: CombineQuestionResultsWithCommentsResponse

דוגמה

דוגמה של combineCommentsWithQuestionResults

Copy

utility::string_t tenantId = utility::string_t("my-tenant-123");
CombineCommentsWithQuestionResultsOptions options;
options.questionId = utility::string_t("question-789");
options.maxComments = boost::optional<int>(50);
api->combineCommentsWithQuestionResults(tenantId, options).then(
    [](pplx::task<std::shared_ptr<CombineQuestionResultsWithCommentsResponse>> task){
        try{
            auto respPtr = task.get();
            auto combined = std::make_shared<CombineQuestionResultsWithCommentsResponse>(*respPtr);
            // השתמש ב‑combined לפי הצורך
        }catch(const std::exception&){
        }
    });

הוסף משתמש SSO

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
createAPISSOUserData	CreateAPISSOUserData	כן

תגובה

מחזיר: AddSSOUserAPIResponse

דוגמה

addSSOUser דוגמה

Copy

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

מחק משתמש SSO

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
id	string	כן
options	const DeleteSSOUserOptions&	כן

תגובה

מחזיר: DeleteSSOUserAPIResponse

דוגמה

דוגמה deleteSSOUser

Copy

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

קבל משתמש SSO לפי אימייל

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
email	string	Yes

תגובה

מחזיר: GetSSOUserByEmailAPIResponse

דוגמה

getSSOUserByEmail דוגמה

Copy

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

קבל משתמש SSO לפי מזהה

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
id	string	Yes

תגובה

מחזיר: GetSSOUserByIdAPIResponse

דוגמה

דוגמת getSSOUserById

Copy

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

קבל משתמשי SSO

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
skip	int32_t	לא

תגובה

מחזיר: GetSSOUsersResponse

דוגמה

דוגמת getSSOUsers

Copy

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

עדכן חלקית משתמש SSO

Parameters

שם	סוג	נדרש
tenantId	string	כן
id	string	כן
updateAPISSOUserData	UpdateAPISSOUserData	כן
updateComments	bool	לא

Response

מחזיר: PatchSSOUserAPIResponse

דוגמה

patchSSOUser דוגמה

Copy

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

הצב משתמש SSO

פרמטרים

שם	סוג	דרוש
tenantId	string	כן
id	string	כן
updateAPISSOUserData	UpdateAPISSOUserData	כן
updateComments	bool	לא

תגובה

מחזיר: PutSSOUserAPIResponse

דוגמה

דוגמת putSSOUser

Copy

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

צור מנוי

Parameters

שם	סוג	חובה	תיאור
tenantId	string	Yes
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Yes

תגובה

מחזיר: CreateSubscriptionAPIResponse

דוגמה

createSubscription דוגמה

Copy

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

מחק מנוי

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
id	string	Yes
userId	string	No

תגובה

מחזירה: DeleteSubscriptionAPIResponse

דוגמה

דוגמה למחיקת מנוי

Copy

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

קבל מנויים

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
userId	string	No

תגובה

מחזיר: GetSubscriptionsAPIResponse

דוגמה

דוגמת getSubscriptions

Copy

auto tenant = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> user = utility::conversions::to_string_t("user@example.com");
api->getSubscriptions(tenant, user).then(
    [](pplx::task<std::shared_ptr<GetSubscriptionsAPIResponse>> t) {
        try {
            auto response = t.get();
            // לעבד תגובה
        } catch (const std::exception& e) {
            // לטפל בשגיאה
        }
    }
);

עדכן מנוי

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
id	string	Yes
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	Yes
userId	string	No

תגובה

מחזיר: UpdateSubscriptionAPIResponse

דוגמה

דוגמת updateSubscription

Copy

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

קבל שימוש יומי של שוכר

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
options	const GetTenantDailyUsagesOptions&	כן

תגובה

מחזיר: GetTenantDailyUsagesResponse

דוגמה

דוגמה ל‑getTenantDailyUsages

Copy

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

צור חבילת שוכר

Parameters

שם	סוג	נדרש	תיאור
tenantId	string	כן
createTenantPackageBody	CreateTenantPackageBody	כן

Response

מחזיר: CreateTenantPackageResponse

Example

דוגמת createTenantPackage

Copy

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

מחק חבילת שוכר

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
id	string	כן

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמת deleteTenantPackage

Copy

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

קבל חבילת שוכר

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
id	string	כן

תגובה

מחזיר: GetTenantPackageResponse

דוגמה

דוגמת getTenantPackage

Copy

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

קבל חבילות שוכר

Parameters

Name	Type	Required	Description
tenantId	string	כן
skip	double	לא

Response

מחזיר: GetTenantPackagesResponse

Example

דוגמת getTenantPackages

Copy

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

החלף חבילת שוכר

פרמטרים

שם	סוג	חובה
tenantId	string	כן
id	string	כן
replaceTenantPackageBody	ReplaceTenantPackageBody	כן

תגובה

מחזיר: APIEmptyResponse

דוגמה

replaceTenantPackage דוגמה

Copy

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

עדכן חבילת שוכר

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
id	string	Yes
updateTenantPackageBody	UpdateTenantPackageBody	Yes

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמה ל‑updateTenantPackage

Copy

auto body = std::make_shared<UpdateTenantPackageBody>();
body->packageId = utility::conversions::to_string_t("premium-plan");
body->expirationDate = utility::conversions::to_string_t("2025-12-31");
body->notes = boost::optional<utility::string_t>(utility::conversions::to_string_t("Upgraded package"));
api->updateTenantPackage(utility::conversions::to_string_t("my-tenant-123"),
                         utility::conversions::to_string_t("pkg-456"),
                         body)
    .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> task) {
        try {
            auto response = task.get();
            // טיפול בהצלחה
        } catch (const std::exception& ex) {
            // טיפול בשגיאה
        }
    });

צור משתמש שוכר

פרמטרים

Name	Type	Required	Description
tenantId	string	כן
createTenantUserBody	CreateTenantUserBody	כן

תגובה

Returns: CreateTenantUserResponse

דוגמה

createTenantUser דוגמה

Copy

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

מחק משתמש שוכר

פרמטרים

Name	Type	Required
tenantId	string	כן
id	string	כן
options	const DeleteTenantUserOptions&	כן

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמת deleteTenantUser

Copy

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

קבל משתמש שוכר

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
id	string	כן

תגובה

מחזיר: GetTenantUserResponse

דוגמה

דוגמת getTenantUser

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user@example.com");
api->getTenantUser(tenantId, userId)
    .then([](pplx::task<std::shared_ptr<GetTenantUserResponse>> task) {
        try {
            auto response = task.get();
            // השתמש בתשובה לפי הצורך
        } catch (const std::exception&) {
            // טיפול בשגיאה
        }
    });

קבל משתמשי שוכר

פרמטרים

שם	סוג	חובה	תיאור
tenantId	string	כן
skip	double	לא

תגובה

מחזיר: GetTenantUsersResponse

דוגמה

דוגמת getTenantUsers

Copy

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

החלף משתמש שוכר

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
id	string	Yes
replaceTenantUserBody	ReplaceTenantUserBody	Yes
updateComments	string	No

תגובה

מחזיר: APIEmptyResponse

דוגמה

replaceTenantUser דוגמה

Copy

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

שלח קישור התחברות

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
id	string	Yes
redirectURL	string	No

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמת sendLoginLink

Copy

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

עדכן משתמש שוכר

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
id	string	Yes
updateTenantUserBody	UpdateTenantUserBody	Yes
updateComments	string	No

תשובה

מחזיר: APIEmptyResponse

דוגמה

דוגמת updateTenantUser

Copy

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

צור שוכר

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
createTenantBody	CreateTenantBody	כן

תגובה

מחזיר: CreateTenantResponse

דוגמה

דוגמת createTenant

Copy

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

מחק שוכר

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
id	string	Yes
sure	string	No

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמה למחיקת deleteTenant

Copy

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

קבל שוכר

Parameters

שם	סוג	נדרש	תיאור
tenantId	string	כן
id	string	כן

תגובה

מחזיר: GetTenantResponse

דוגמה

דוגמת getTenant

Copy

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

קבל שוכרים

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
options	const GetTenantsOptions&	כן

תגובה

מחזיר: GetTenantsResponse

דוגמה

דוגמה getTenants

Copy

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

עדכן שוכר

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
id	string	Yes
updateTenantBody	UpdateTenantBody	Yes

תגובה

מחזיר: APIEmptyResponse

דוגמה

דוגמת updateTenant

Copy

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

שנה מצב כרטיס

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
userId	string	כן
id	string	כן
changeTicketStateBody	ChangeTicketStateBody	כן

תגובה

מחזיר: ChangeTicketStateResponse

דוגמה

דוגמת changeTicketState

Copy

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

צור כרטיס

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
userId	string	Yes
createTicketBody	CreateTicketBody	Yes

תשובה

מחזיר: CreateTicketResponse

דוגמה

דוגמה createTicket

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("john.doe@example.com");
CreateTicketBody ticketBody;
ticketBody.setSubject(utility::conversions::to_string_t("Login Issue"));
ticketBody.setDescription(utility::conversions::to_string_t("Cannot log in after password reset."));
boost::optional<int> priority = 2;
ticketBody.setPriority(priority);
api->createTicket(tenantId, userId, ticketBody).then([](pplx::task<std::shared_ptr<CreateTicketResponse>> task){
    try{
        auto response = task.get();
        // השתמש בתגובה לפי הצורך
    }catch(const std::exception&){
        // טיפול בשגיאה
    }
});

קבל כרטיס

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
id	string	Yes
userId	string	No

תגובה

מחזיר: GetTicketResponse

דוגמה

getTicket דוגמה

Copy

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

קבל כרטיסים

פרמטרים

שם	סוג	נחוץ	תיאור
tenantId	string	Yes
options	const GetTicketsOptions&	Yes

תגובה

מחזיר: GetTicketsResponse

דוגמה

דוגמת getTickets

Copy

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

קבל תרגומים

Parameters

שם	סוג	חובה
r_namespace	string	Yes
component	string	Yes
options	const GetTranslationsOptions&	Yes

תגובה

מחזיר: GetTranslationsResponse

דוגמה

דוגמה getTranslations

Copy

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

העלה תמונה

העלאת ושינוי גודל של תמונה

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
file	HttpContent	כן
options	const UploadImageOptions&	כן

תגובה

מחזיר: UploadImageResponse

דוגמה

דוגמת uploadImage

Copy

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

קבל התקדמות תג משתמש לפי מזהה

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
id	string	Yes

תגובה

מחזיר: APIGetUserBadgeProgressResponse

דוגמה

דוגמה ל‑getUserBadgeProgressById

Copy

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

קבל התקדמות תג משתמש לפי מזהה משתמש

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
userId	string	כן

תגובה

מחזיר: APIGetUserBadgeProgressResponse

דוגמה

דוגמת getUserBadgeProgressByUserId

Copy

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

קבל רשימת התקדמות תגים של משתמש

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
options	const GetUserBadgeProgressListOptions&	Yes

תגובה

מחזיר: APIGetUserBadgeProgressListResponse

דוגמה

דוגמת getUserBadgeProgressList

Copy

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

צור תג משתמש

פרמטרים

שם	סוג	חובה	תיאור
tenantId	string	Yes
createUserBadgeParams	CreateUserBadgeParams	Yes

תגובה

מחזיר: APICreateUserBadgeResponse

דוגמה

דוגמת createUserBadge

Copy

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

מחק תג משתמש

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
id	string	כן

תגובה

מחזיר: APIEmptySuccessResponse

דוגמה

דוגמת deleteUserBadge

Copy

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

קבל תג משתמש

פרמטרים

שם	סוג	חובה	תיאור
tenantId	string	כן
id	string	כן

תגובה

מחזיר: APIGetUserBadgeResponse

דוגמה

דוגמת getUserBadge

Copy

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

קבל תגים של משתמש

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
options	const GetUserBadgesOptions&	Yes

תגובה

מחזיר: APIGetUserBadgesResponse

דוגמה

getUserBadges דוגמה

Copy

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

עדכן תג משתמש

פרמטרים

שם	סוג	חובה
tenantId	string	כן
id	string	כן
updateUserBadgeParams	UpdateUserBadgeParams	כן

תגובה

מחזיר: APIEmptySuccessResponse

דוגמה

דוגמת updateUserBadge

Copy

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

קבל ספירת התראות משתמש

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
sso	string	לא

תגובה

מחזיר: GetUserNotificationCountResponse

דוגמה

דוגמה getUserNotificationCount

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("user@example.com");
api->getUserNotificationCount(tenantId, sso).then([](pplx::task<std::shared_ptr<GetUserNotificationCountResponse>> t){
    try{
        auto resp = t.get();
        // השתמש ב‑resp לפי הצורך
    }catch(const std::exception&){
        // טיפול בשגיאה
    }
});

קבל התראות משתמש

פרמטרים

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

תגובה

מחזיר: GetMyNotificationsResponse

דוגמה

דוגמת getUserNotifications

Copy

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

אפס ספירת התראות משתמש

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	כן
sso	string	לא

תגובה

מחזיר: ResetUserNotificationsResponse

דוגמה

resetUserNotificationCount דוגמה

Copy

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

אפס התראות משתמש

פרמטרים

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

תגובה

מחזיר: ResetUserNotificationsResponse

דוגמה

דוגמת resetUserNotifications

Copy

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

עדכן סטטוס מנוי התראות על תגובה

הפעל או בטל התראות לתגובה ספציפית.

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
notificationId	string	Yes
optedInOrOut	string	Yes
commentId	string	Yes
sso	string	No

תגובה

מחזיר: UpdateUserNotificationCommentSubscriptionStatusResponse

דוגמה

דוגמה ל‑updateUserNotificationCommentSubscriptionStatus

Copy

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

עדכן סטטוס מנוי התראות על דף

אפשר או בטל התראות עבור דף. כאשר משתמשים מנויים לדף, נוצרות התראות עבור תגובות שורש חדשות, וגם

פרמטרים

שם	סוג	חובה
tenantId	string	Yes
urlId	string	Yes
url	string	Yes
pageTitle	string	Yes
subscribedOrUnsubscribed	string	Yes
sso	string	No

תגובה

מחזיר: UpdateUserNotificationPageSubscriptionStatusResponse

דוגמה

updateUserNotificationPageSubscriptionStatus דוגמה

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("page-456");
utility::string_t url = U("https://example.com/articles/awesome-article");
utility::string_t pageTitle = U("Awesome Article");
utility::string_t subscription = U("subscribed");
boost::optional<utility::string_t> sso = boost::make_optional<utility::string_t>(U("sso-token-789"));
api->updateUserNotificationPageSubscriptionStatus(tenantId, urlId, url, pageTitle, subscription, sso)
    .then([](std::shared_ptr<UpdateUserNotificationPageSubscriptionStatusResponse> resp) {
        // עיבוד resp אם נדרש
    });

עדכן סטטוס התראה של משתמש

פרמטרים

שם	סוג	נדרש
tenantId	string	כן
notificationId	string	כן
newStatus	string	כן
sso	string	לא

תגובה

מחזיר: UpdateUserNotificationStatusResponse

דוגמה

updateUserNotificationStatus דוגמה

Copy

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

קבל סטטוס נוכחות משתמש

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
urlIdWS	string	Yes
userIds	string	Yes

תגובה

מחזירה: GetUserPresenceStatusesResponse

דוגמה

דוגמת getUserPresenceStatuses

Copy

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

חפש משתמשים

Parameters

Name	Type	Required
tenantId	string	כן
urlId	string	כן
options	const SearchUsersOptions&	כן

Response

מחזיר: SearchUsersResult

Example

דוגמת searchUsers

Copy

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

קבל משתמש

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

תגובה

מחזיר: GetUserResponse

דוגמה

דוגמת getUser

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user-789");
boost::optional<utility::string_t> optTag = boost::none;
api->getUser(tenantId, userId)
    .then([=](pplx::task<std::shared_ptr<GetUserResponse>> task) {
        try {
            auto response = task.get();
            if (!response) {
                response = std::make_shared<GetUserResponse>();
            }
            // עיבוד התגובה לפי הצורך
        } catch (const std::exception&) {
            // טיפול בשגיאה
        }
    });

צור הצבעה

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
commentId	string	Yes
direction	string	Yes
options	const CreateVoteOptions&	Yes

תגובה

מחזיר: VoteResponse

דוגמה

createVote דוגמה

Copy

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

מחק הצבעה

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
id	string	Yes
editKey	string	No

תגובה

מחזיר: VoteDeleteResponse

דוגמה

דוגמת deleteVote

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto voteId = utility::conversions::to_string_t("vote-9876");
boost::optional<utility::string_t> editKey = utility::conversions::to_string_t("edit-abc123");
api->deleteVote(tenantId, voteId, editKey).then([](pplx::task<std::shared_ptr<VoteDeleteResponse>> task) {
    try {
        auto response = task.get();
        // יש לעבד את התגובה כנדרש
    } catch (const std::exception&) {
        // טיפול ב‑שגיאה
    }
});

קבל הצבעות

פרמטרים

שם	סוג	נדרש	תיאור
tenantId	string	Yes
urlId	string	Yes

תגובה

מחזיר: GetVotesResponse

דוגמה

דוגמת getVotes

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto urlId = utility::string_t(U("article-456"));
boost::optional<utility::string_t> extraHeader = boost::none;
api->getVotes(tenantId, urlId).then([=](pplx::task<std::shared_ptr<GetVotesResponse>> task) {
    try {
        auto original = task.get();
        auto response = std::make_shared<GetVotesResponse>(*original);
    } catch (...) {
        // טיפול בשגיאה
    }
});

קבל הצבעות למשתמש

פרמטרים

שם	סוג	נדרש
tenantId	string	Yes
urlId	string	Yes
options	const GetVotesForUserOptions&	Yes

תגובה

מחזיר: GetVotesForUserResponse

דוגמה

דוגמת getVotesForUser

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto urlId = utility::string_t(U("post-456"));
GetVotesForUserOptions options;
options.page = boost::optional<int>(2);
options.pageSize = boost::optional<int>(50);
api->getVotesForUser(tenantId, urlId, options).then([](std::shared_ptr<GetVotesForUserResponse> response) {
    if (response) {
        // לטפל בתגובה, למשל, לעבור על הקולות
    }
});

צריכים עזרה?

אם תיתקלו בבעיות או יש לכם שאלות לגבי ה-SDK של C++, נא:

תרומה

תרומות מתקבלות בברכה! אנא בקרו ב-מאגר GitHub לקבלת הנחיות לתרומה.

שפה 🇮🇱 עברית

תיעוד

התחלה

תיעוד API

שימוש

אגרגציה

יומני ביקורת

אימות

חסימה מהתגובה

בדיקת תגובות חסומות

תגובות

תגובות למשתמש

תצורות תחום

תבניות אימייל

יומן אירועים

פוסטים בפיד

סימון תגובה

GIFים

תגיות

מודרציה

מודרטורים

ספירת התראות

התראות

תגובות לדף

דפים

אירועי ווב‑הוק ממתינים

תצורות שאלות

תוצאות שאלות

אגרגציית תוצאות שאלות

משתמשי SSO

מנויים

שימוש יומי של שוכר

חבילות שוכר

משתמשי שוכר

שוכרים

כרטיסים

תרגומים

העלאת תמונה

התקדמות תגים של משתמש

תגי משתמש

התראות משתמש

סטטוס נוכחות משתמש

חיפוש משתמשים

משתמשים

הצבעות

FastComments SDK ב‑C++

מאגר

סוכני קידוד AI

דרישות

התקנה

התקנת תלותים

בנייה ממקור

התקנה

תכולת הספרייה

API ציבוריים מול מאובטחים

התחלה מהירה

שימוש ב-API מאומתים (DefaultAPI)

שימוש ב-API ציבוריים (PublicAPI)

שימוש ב-API של מודרציה (ModerationApi)

בעיות נפוצות

ביצוע קריאות API: סינכרוני מול אסינכרוני

Synchronous Calls with .get()

Asynchronous Calls with .then()

Choosing Between Synchronous and Asynchronous

הערות

Broadcast Ids

SSO (כניסה יחידה)

שימוש ב‑SSO

SSO פשוט

SSO מאובטח

תיעוד עבור fastcomments

Documentation for API Endpoints

Documentation for Models

Documentation for Authorization

api_key

אגרגציה

Parameters

Response

Example

קבל יומני ביקורת

Synchronous Calls with `.get()`

Asynchronous Calls with `.then()`