FastComments SDK של C++

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

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

מאגר

דרישות

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

תיעוד עבור נקודות קצה של API

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

מחלקה	מתודה	בקשת HTTP	תיאור
DefaultApi	addDomainConfig	POST /api/v1/domain-configs
DefaultApi	addHashTag	POST /api/v1/hash-tags
DefaultApi	addHashTagsBulk	POST /api/v1/hash-tags/bulk
DefaultApi	addPage	POST /api/v1/pages
DefaultApi	addSSOUser	POST /api/v1/sso-users
DefaultApi	aggregate	POST /api/v1/aggregate	מאגד מסמכים על‑ידי קיבוץ שלהם (באם מתווסף groupBy) ויישום של מספר פעולות. נתמכות פעולות שונות (למשל sum, countDistinct, avg וכו').
DefaultApi	aggregateQuestionResults	GET /api/v1/question-results-aggregation
DefaultApi	blockUserFromComment	POST /api/v1/comments/{id}/block
DefaultApi	bulkAggregateQuestionResults	POST /api/v1/question-results-aggregation/bulk
DefaultApi	changeTicketState	PATCH /api/v1/tickets/{id}/state
DefaultApi	combineCommentsWithQuestionResults	GET /api/v1/question-results-aggregation/combine/comments
DefaultApi	createEmailTemplate	POST /api/v1/email-templates
DefaultApi	createFeedPost	POST /api/v1/feed-posts
DefaultApi	createModerator	POST /api/v1/moderators
DefaultApi	createQuestionConfig	POST /api/v1/question-configs
DefaultApi	createQuestionResult	POST /api/v1/question-results
DefaultApi	createSubscription	POST /api/v1/subscriptions
DefaultApi	createTenant	POST /api/v1/tenants
DefaultApi	createTenantPackage	POST /api/v1/tenant-packages
DefaultApi	createTenantUser	POST /api/v1/tenant-users
DefaultApi	createTicket	POST /api/v1/tickets
DefaultApi	createUserBadge	POST /api/v1/user-badges
DefaultApi	createVote	POST /api/v1/votes
DefaultApi	deleteComment	DELETE /api/v1/comments/{id}
DefaultApi	deleteDomainConfig	DELETE /api/v1/domain-configs/{domain}
DefaultApi	deleteEmailTemplate	DELETE /api/v1/email-templates/{id}
DefaultApi	deleteEmailTemplateRenderError	DELETE /api/v1/email-templates/{id}/render-errors/{errorId}
DefaultApi	deleteHashTag	DELETE /api/v1/hash-tags/{tag}
DefaultApi	deleteModerator	DELETE /api/v1/moderators/{id}
DefaultApi	deleteNotificationCount	DELETE /api/v1/notification-count/{id}
DefaultApi	deletePage	DELETE /api/v1/pages/{id}
DefaultApi	deletePendingWebhookEvent	DELETE /api/v1/pending-webhook-events/{id}
DefaultApi	deleteQuestionConfig	DELETE /api/v1/question-configs/{id}
DefaultApi	deleteQuestionResult	DELETE /api/v1/question-results/{id}
DefaultApi	deleteSSOUser	DELETE /api/v1/sso-users/{id}
DefaultApi	deleteSubscription	DELETE /api/v1/subscriptions/{id}
DefaultApi	deleteTenant	DELETE /api/v1/tenants/{id}
DefaultApi	deleteTenantPackage	DELETE /api/v1/tenant-packages/{id}
DefaultApi	deleteTenantUser	DELETE /api/v1/tenant-users/{id}
DefaultApi	deleteUserBadge	DELETE /api/v1/user-badges/{id}
DefaultApi	deleteVote	DELETE /api/v1/votes/{id}
DefaultApi	flagComment	POST /api/v1/comments/{id}/flag
DefaultApi	getAuditLogs	GET /api/v1/audit-logs
DefaultApi	getCachedNotificationCount	GET /api/v1/notification-count/{id}
DefaultApi	getComment	GET /api/v1/comments/{id}
DefaultApi	getComments	GET /api/v1/comments
DefaultApi	getDomainConfig	GET /api/v1/domain-configs/{domain}
DefaultApi	getDomainConfigs	GET /api/v1/domain-configs
DefaultApi	getEmailTemplate	GET /api/v1/email-templates/{id}
DefaultApi	getEmailTemplateDefinitions	GET /api/v1/email-templates/definitions
DefaultApi	getEmailTemplateRenderErrors	GET /api/v1/email-templates/{id}/render-errors
DefaultApi	getEmailTemplates	GET /api/v1/email-templates
DefaultApi	getFeedPosts	GET /api/v1/feed-posts	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}	נדרש tenantId urlId
PublicApi	getEventLog	GET /event-log/{tenantId}	נדרש tenantId urlId userIdWS
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	נדרש tenantId afterId
PublicApi	getFeedPostsStats	GET /feed-posts/{tenantId}/stats
PublicApi	getGifLarge	GET /gifs/get-large/{tenantId}
PublicApi	getGifsSearch	GET /gifs/search/{tenantId}
PublicApi	getGifsTrending	GET /gifs/trending/{tenantId}
PublicApi	getGlobalEventLog	GET /event-log/global/{tenantId}	נדרש tenantId urlId userIdWS
PublicApi	getOfflineUsers	GET /pages/{tenantId}/users/offline	מגיבים קודמים לדף שאינם מחוברים כעת. ממוין לפי displayName. השתמש בזה לאחר שמיצית את /users/online כדי להציג חלק "Members". דפדוף בעזרת מצביע על שם מגיב: השרת מקפיץ את חיפוש החלק {tenantId, urlId, commenterName} אחרי afterName קדימה באמצעות $gt, ללא עלות $skip.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	משתמשים שמקושרים כעת לצפייה בדף: אנשים שה‑websocket שלהם מנוי לשף כרגע. מחזיר anonCount + totalCount (מנויים לכל החדר, כולל צופים אנונימיים שאינם מפורטים).
PublicApi	getPagesPublic	GET /pages/{tenantId}	רשימת דפים לשוכר. משומשת על‑ידי לקוח ה‑desktop של FChat למלא את רשימת החדרים שלו. דורש שה‑`enableFChat` יהיה true בתצורה המותאמת של כל דף. דפים הדורשים SSO מסוננים לפי גישת קבוצת המשתמש המבקש.
PublicApi	getTranslations	GET /translations/{namespace}/{component}
PublicApi	getUserNotificationCount	GET /user-notifications/get-count
PublicApi	getUserNotifications	GET /user-notifications
PublicApi	getUserPresenceStatuses	GET /user-presence-status
PublicApi	getUserReactsPublic	GET /feed-posts/{tenantId}/user-reacts
PublicApi	getUsersInfo	GET /pages/{tenantId}/users/info	מידע משותף של משתמשים לשוכר. עם userIds, מחזיר מידע תצוגה מ‑User / SSOUser. משמש את הווידג'ט להעשיר משתמשים שהופיעו זה עתה דרך אירוע נוכחות. ללא הקשר דף: פרטיות מוחלטת (פרופילים פרטיים מוסווים).
PublicApi	getV1PageLikes	GET /page-reacts/v1/likes/{tenantId}
PublicApi	getV2PageReactUsers	GET /page-reacts/v2/{tenantId}/list
PublicApi	getV2PageReacts	GET /page-reacts/v2/{tenantId}
PublicApi	lockComment	POST /comments/{tenantId}/{commentId}/lock
PublicApi	logoutPublic	PUT /auth/logout
PublicApi	pinComment	POST /comments/{tenantId}/{commentId}/pin
PublicApi	reactFeedPostPublic	POST /feed-posts/{tenantId}/react/{postId}
PublicApi	resetUserNotificationCount	POST /user-notifications/reset-count
PublicApi	resetUserNotifications	POST /user-notifications/reset
PublicApi	searchUsers	GET /user-search/{tenantId}
PublicApi	setCommentText	POST /comments/{tenantId}/{commentId}/update-text
PublicApi	unBlockCommentPublic	DELETE /block-from-comment/{commentId}
PublicApi	unLockComment	POST /comments/{tenantId}/{commentId}/unlock
PublicApi	unPinComment	POST /comments/{tenantId}/{commentId}/unpin
PublicApi	updateFeedPostPublic	PUT /feed-posts/{tenantId}/{postId}
PublicApi	updateUserNotificationCommentSubscriptionStatus	POST /user-notifications/{notificationId}/mark-opted/{optedInOrOut}	הפעלה או השבתה של הודעות עבור תגובה ספציפית.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	הפעלה או השבתה של הודעות עבור דף. כאשר משתמשים מנויים לדף, נוצרות הודעות עבור תגובות שורש חדשות, וכן
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	העלאה ושינוי גודל של תמונה
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

תיעוד עבור מודלים

אגרגציה

אגמת מסמכים על ידי קיבוץ שלהם (אם מסופק 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;
        }
   });

חיפוש גיפים

פרמטרים

שם	סוג	נדרש
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&){
    }
});

גיפים חמים

פרמטרים

שם	סוג	נדרש	תיאור
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/Id

פרמטרים

שם	סוג	נדרש	תיאור
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
    }
});

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

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

Parameters

Name	Type	Required	Description
tenantId	string	Yes
ids	string	Yes

Response

Returns: PageUsersInfoResponse

Example

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

מחיקת אירוע webhook מושהה

פרמטרים

שם	סוג	נדרש	תיאור
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) { }
    });

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

פרמטרים

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

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

פרמטרים

שם	סוג	נדרש	תיאור
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 לפי Id

פרמטרים

שם	סוג	נדרש	תיאור
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();
});

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

פרמטרים

שם	סוג	נדרש	תיאור
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

שימוש

אגרגציה

יומני ביקורת

אימות

חסימה מתגובה

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

תגובות

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

הגדרות דומיין

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

יומן אירועים

פוסטים

סימון תגובה

גיפים

האשטאגים

מודרציה

ממונים

ספירת התראות

התראות

ריאקציות בעמוד

עמודים

אירועי webhook בהמתנה

הגדרות שאלון

תוצאות שאלון

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

משתמשי SSO

מנויים

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

חבילות שוכר

משתמשי שוכר

שוכרים

טיקטים

תרגומים

העלאת תמונה

התקדמות תג משתמש

תגי משתמש

התראות משתמש

מצב נוכחות משתמש

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

משתמשים

הצבעות

FastComments SDK של C++

מאגר

דרישות

התקנה

התקנת תלותים

בנייה ממקור

התקנה

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

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

תיעוד עבור נקודות קצה של API

תיעוד עבור מודלים

אגרגציה

Parameters

Response

Example

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

פרמטרים

תגובה

דוגמה

Synchronous Calls with `.get()`

Asynchronous Calls with `.then()`