FastComments C++ SDK

यह FastComments का आधिकारिक C++ SDK है।

अपने C++ एप्लिकेशन से कमेंट्स, यूज़र्स, SSO और मॉडरेशन को प्रबंधित करें।

रिपॉज़िटरी

AI coding agents

अपने कोडिंग एजेंट को FastComments का वह संदर्भ दें जिसकी उसे आवश्यकता है - विजेट्स, कॉन्फ़िगरेशन, Secure SSO, REST API, और SDKs:

npx skills add fastcomments/skills

यह Claude Code, Codex, Cursor, Copilot, Gemini, और skills CLI द्वारा समर्थित हर अन्य एजेंट के साथ काम करता है।

Requirements

C++17 या बाद का संस्करण
CMake 3.14 या बाद का संस्करण
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (टेस्टिंग के लिए स्वतः डाउनलोड हो जाता है)

Installation

डिपेंडेंसीज़ इंस्टॉल करें

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 सेशन कुकी के माध्यम से प्रमाणीकरण कर सकता है।

Quick Start

प्रमाणित APIs का उपयोग (DefaultAPI)

महत्वपूर्ण:

आपको बेस URL सेट करना होगा (cpp-restsdk जनरेटर इसे OpenAPI spec से नहीं पढ़ता)
प्रमाणित अनुरोध करने से पहले आपको ApiClient पर अपनी API key सेट करनी होगी। यदि आप ऐसा नहीं करते, तो अनुरोध 401 त्रुटि के साथ विफल होंगे।

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

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

    // आवश्यक: बेस URL सेट करें (अपना region चुनें)
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));  // US
    // या: config->setBaseUrl(utility::conversions::to_string_t("https://eu.fastcomments.com"));  // EU

    // आवश्यक: अपनी API key सेट करें
    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;
}

सार्वजनिक APIs का उपयोग (PublicAPI)

सार्वजनिक endpoints के लिए प्रमाणीकरण की आवश्यकता नहीं है:

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

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

    // आवश्यक: बेस URL सेट करें
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

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

    // सार्वजनिक API कॉल करें
    return 0;
}

मॉडरेशन APIs का उपयोग (ModerationApi)

ModerationApi मॉडरेटर डैशबोर्ड को संचालित करता है। हर method एक sso parameter स्वीकार करता है ताकि कॉल एक SSO-प्रमाणित मॉडरेटर की ओर से चले (token बनाने का तरीका नीचे SSO अनुभाग देखें):

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

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

    // आवश्यक: बेस URL सेट करें
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

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

    // कॉल को प्रमाणित करने के लिए मॉडरेटर का SSO token पास करें
    auto ssoToken = utility::conversions::to_string_t("YOUR_MODERATOR_SSO_TOKEN");

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

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

    return 0;
}

सामान्य समस्याएँ

"URI must contain a hostname" त्रुटि: सुनिश्चित करें कि आपने ApiClient बनाने से पहले config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) कॉल किया है। cpp-restsdk जनरेटर OpenAPI spec से server URL स्वचालित रूप से नहीं पढ़ता।
401 "missing-api-key" त्रुटि: सुनिश्चित करें कि आपने DefaultAPI instance बनाने से पहले config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) कॉल किया है।
गलत API class: server-side प्रमाणित अनुरोधों के लिए DefaultApi, client-side/सार्वजनिक अनुरोधों के लिए PublicApi, और मॉडरेटर डैशबोर्ड अनुरोधों के लिए ModerationApi (मॉडरेटर SSO token से प्रमाणित) का उपयोग करें।

Making API Calls: Synchronous vs Asynchronous

इस SDK के सभी API मेथड्स C++ REST SDK से pplx::task<std::shared_ptr<ResponseType>> रिटर्न करते हैं। इससे आपको API रिस्पॉन्स को हैंडल करने के तरीके में लचीलापन मिलता है।

`.get()` के साथ सिंक्रोनस कॉल्स

कॉलिंग थ्रेड को ब्लॉक करने और रिज़ल्ट को सिंक्रोनस रूप से प्राप्त करने के लिए .get() का उपयोग करें, जब तक कि रिक्वेस्ट पूरी न हो जाए:

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

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

// आवश्यक पैरामीटर पोज़िशनल होते हैं; वैकल्पिक पैरामीटर options स्ट्रक्चर में जाते हैं
org::openapitools::client::api::GetCommentsOptions options;
options.urlId = utility::conversions::to_string_t("your-url-id");

// ब्लॉक करने और रिज़ल्ट को सिंक्रोनस रूप से प्राप्त करने के लिए .get() कॉल करें
auto response = api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    options
).get();  // HTTP रिक्वेस्ट पूरा होने तक ब्लॉक करता है

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

`.then()` के साथ एसिंक्रोनस कॉल्स

कॉलबैक के साथ नॉन-ब्लॉकिंग एसिंक्रोनस एक्ज़ीक्यूशन के लिए .then() का उपयोग करें:

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

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

// आवश्यक पैरामीटर पोज़िशनल होते हैं; वैकल्पिक पैरामीटर options स्ट्रक्चर में जाते हैं
org::openapitools::client::api::GetCommentsOptions options;
options.urlId = utility::conversions::to_string_t("your-url-id");

// कॉलबैक-आधारित एसिंक्रोनस एक्ज़ीक्यूशन के लिए .then() का उपयोग करें
api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    options
).then([](std::shared_ptr<GetComments_200_response> response) {
    // रिक्वेस्ट पूरा होने पर यह एसिंक्रोनस रूप से चलता है
    if (response && response->comments) {
        std::cout << "Found " << response->comments->size() << " comments" << std::endl;
    }
});

// एक्ज़ीक्यूशन बिना ब्लॉक किए तुरंत आगे बढ़ जाता है
std::cout << "Request sent, continuing..." << std::endl;

सिंक्रोनस और एसिंक्रोनस में से चुनाव

चुनाव आपके रनटाइम एनवायरनमेंट और एप्लिकेशन आर्किटेक्चर पर निर्भर करता है:

.get() (सिंक्रोनस ब्लॉकिंग)

HTTP रिक्वेस्ट पूरा होने तक कॉलिंग थ्रेड को ब्लॉक करता है
सरल कोड फ्लो, समझने में आसान
समर्पित वर्कर थ्रेड्स, बैच प्रोसेसिंग, या कमांड-लाइन टूल्स के लिए उपयुक्त
इवेंट लूप्स, GUI थ्रेड्स, या सिंगल-थ्रेडेड सर्वर के लिए उपयुक्त नहीं

.then() (एसिंक्रोनस नॉन-ब्लॉकिंग)

तुरंत रिटर्न करता है, रिक्वेस्ट पूरा होने पर कॉलबैक एक्ज़ीक्यूट होता है
कॉलिंग थ्रेड को ब्लॉक नहीं करता
इवेंट-ड्रिवन आर्किटेक्चर, GUI एप्लिकेशन, या सिंगल-थ्रेडेड इवेंट लूप्स के लिए आवश्यक
कई ऑपरेशन्स को चेन करने की अनुमति देता है
अधिक जटिल कंट्रोल फ्लो

SDK का टेस्ट सूट केवल .get() का उपयोग करता है, लेकिन यह टेस्ट एनवायरनमेंट के लिए उपयुक्त है जहाँ ब्लॉकिंग स्वीकार्य है।

Notes

ब्रॉडकास्ट आईडी

आप देखेंगे कि कुछ API कॉल में broadcastId पास करना अपेक्षित है। जब आप इवेंट प्राप्त करते हैं, तो आपको यह आईडी वापस मिलेगी, ताकि यदि आप क्लाइंट पर ऑप्टिमिस्टिक रूप से बदलाव लागू करने की योजना बनाते हैं (जो आप शायद करना चाहेंगे क्योंकि यह सबसे अच्छा अनुभव प्रदान करता है), तो आप उस इवेंट को अनदेखा कर सकें। यहाँ एक UUID पास करें। यह आईडी इतनी अद्वितीय होनी चाहिए कि वह एक ब्राउज़र सत्र में दो बार न आए।

SSO (सिंगल साइन-ऑन)

SSO उदाहरणों के लिए, नीचे देखें।

SSO Usage

सरल 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;
}

Documentation for fastcomments

Documentation for API Endpoints

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

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

Documentation for Models

Documentation for Authorization

api_key

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

aggregate

दस्तावेज़ों को समूहित करके (यदि groupBy दिया गया है) एकत्रित करता है और कई ऑपरेशन लागू करता है। विभिन्न ऑपरेशन (जैसे sum, countDistinct, avg, आदि) समर्थित हैं।

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
aggregationRequest	AggregationRequest	हाँ
options	const AggregateOptions&	हाँ

प्रतिक्रिया

लौटाता है: AggregateResponse

उदाहरण

aggregate उदाहरण

Copy

utility::string_t tenantId = U("my-tenant-123");
AggregationRequest aggregationRequest;
aggregationRequest.setMetric(U("commentCount"));
aggregationRequest.setStartDate(U("2023-01-01T00:00:00Z"));
aggregationRequest.setEndDate(U("2023-12-31T23:59:59Z"));
aggregationRequest.setFilters({ U("status:approved") });
AggregateOptions options;
options.limit = boost::optional<int>(100);
options.includeMetadata = boost::optional<bool>(true);
api->aggregate(tenantId, aggregationRequest, options)
    .then([](pplx::task<std::shared_ptr<AggregateResponse>> task) {
        try {
            auto response = task.get();
            // प्रतिक्रिया प्रोसेस करें
        } catch (const std::exception& e) {
            // त्रुटि संभालें
        }
    });

getAuditLogs

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetAuditLogsOptions&	हाँ

प्रतिक्रिया

लौटाता है: GetAuditLogsResponse

उदाहरण

getAuditLogs उदाहरण

Copy

utility::string_t tenantId = U("my-tenant-123");
GetAuditLogsOptions options;
options.startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-01T00:00:00Z"), utility::datetime::RFC_1123));
options.endDate   = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-31T23:59:59Z"), utility::datetime::RFC_1123));
options.limit     = boost::optional<int>(100);
api->getAuditLogs(tenantId, options).then([](pplx::task<std::shared_ptr<GetAuditLogsResponse>> t) {
    try {
        auto response = t.get();
        // response का उपयोग करें
    } catch (const std::exception& e) {
        // त्रुटि को संभालें
    }
});

logoutPublic

प्रतिक्रिया

रिटर्न करता है: 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;
        }
    });

blockFromCommentPublic

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
publicBlockFromCommentParams	PublicBlockFromCommentParams	हाँ
sso	string	नहीं

प्रतिक्रिया

लौटाता है: BlockSuccess

उदाहरण

blockFromCommentPublic उदाहरण

Copy

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

unBlockCommentPublic

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
publicBlockFromCommentParams	PublicBlockFromCommentParams	हाँ
sso	string	नहीं

प्रतिक्रिया

लौटाता है: 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){ });

checkedCommentsForBlocked

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentIds	string	हाँ
sso	string	नहीं

प्रतिक्रिया

लौटाता है: 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;
});

blockUserFromComment

पैरामीटर

नाम	प्रकार	आवश्यक
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&) { } });

createCommentPublic

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
urlId	string	हाँ
broadcastId	string	हाँ
commentData	CommentData	हाँ
options	const CreateCommentPublicOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: 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;
    });

deleteComment

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
options	const DeleteCommentOptions&	हाँ

प्रतिक्रिया

लौटाता है: DeleteCommentResult

उदाहरण

deleteComment उदाहरण

Copy

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

deleteCommentPublic

पैरामीटर

नाम	प्रकार	आवश्यक
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){
        }
    });

deleteCommentVote

पैरामीटर

नाम	प्रकार	आवश्यक
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;
    }
});

flagComment

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
options	const FlagCommentOptions&	हाँ

प्रतिक्रिया

लौटाता है: FlagCommentResponse

उदाहरण

flagComment उदाहरण

Copy

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

getComment

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
id	string	हाँ

प्रतिक्रिया

रिटर्न करता है: 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&){
    }
});

getComments

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetCommentsOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: 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();
        // आवश्यकतानुसार response का उपयोग करें
    } catch (const std::exception& e) {
        // त्रुटि को संभालें
    }
});

getCommentsPublic

req tenantId urlId

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
urlId	string	हाँ
options	const GetCommentsPublicOptions&	हाँ

प्रतिक्रिया

लौटाता है: 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;
});

getCommentText

पैरामीटर

नाम	प्रकार	आवश्यक
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(...){}
});

getCommentVoteUserNames

पैरामीटर

नाम	प्रकार	आवश्यक
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&){ }
});

lockComment

पैरामीटर

नाम	प्रकार	आवश्यक
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&){
    }
});

pinComment

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
broadcastId	string	हाँ
sso	string	नहीं

प्रतिक्रिया

रिटर्न करता है: 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&) {
        }
    });

saveComment

पैरामीटर

नाम	प्रकार	आवश्यक
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;
    });

setCommentText

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
broadcastId	string	हाँ
commentTextUpdateRequest	CommentTextUpdateRequest	हाँ
options	const SetCommentTextOptions&	हाँ

प्रतिक्रिया

लौटाता है: 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) {
    });

unBlockUserFromComment

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
unBlockFromCommentParams	UnBlockFromCommentParams	हाँ
options	const UnBlockUserFromCommentOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: UnblockSuccess

उदाहरण

unBlockUserFromComment उदाहरण

Copy

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

unFlagComment

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
options	const UnFlagCommentOptions&	हाँ

प्रतिक्रिया

लौटाता है: 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;
            // आवश्यक हो तो status प्रोसेस करें
        }
    })
    .then([](pplx::task<void> previous) {
        try {
            previous.get();
        } catch (const std::exception& e) {
            // त्रुटि को संभालें
        }
    });

unLockComment

पैरामीटर

नाम	प्रकार	आवश्यक
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&) {
    }
});

unPinComment

पैरामीटर

नाम	प्रकार	आवश्यक
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);
});

updateComment

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
updatableCommentParams	UpdatableCommentParams	हाँ
options	const UpdateCommentOptions&	हाँ

प्रतिक्रिया

लौटाता है: 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("संपादित टिप्पणी सामग्री");
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&) {} });

voteComment

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
urlId	string	हाँ
broadcastId	string	हाँ
voteBodyParams	VoteBodyParams	हाँ
options	const VoteCommentOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: VoteResponse

उदाहरण

voteComment उदाहरण

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-7890");
auto urlId = utility::conversions::to_string_t("article-456");
auto broadcastId = utility::conversions::to_string_t("broadcast-321");
VoteBodyParams voteParams;
voteParams.upvote = true;
voteParams.note = boost::optional<utility::string_t>(utility::conversions::to_string_t("Great insight"));
VoteCommentOptions options;
options.dryRun = boost::optional<bool>(false);
api->voteComment(tenantId, commentId, urlId, broadcastId, voteParams, options)
   .then([](pplx::task<std::shared_ptr<VoteResponse>> t) {
       try {
           auto response = t.get();
           // प्रतिक्रिया को संभालें
       } catch (const std::exception&) {
       }
   });

getCommentsForUser

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&){}
});

addDomainConfig

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&){
    }
});

deleteDomainConfig

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&) {
        }
    });

getDomainConfig

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
domain	string	हाँ

प्रतिक्रिया

लौटाता है: GetDomainConfigResponse

उदाहरण

getDomainConfig उदाहरण

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domain = U("myblog.example.com");
api->getDomainConfig(tenantId, domain)
    .then([](std::shared_ptr<GetDomainConfigResponse> response) {
        if (!response) return;
        boost::optional<bool> moderationEnabled = response->moderationEnabled;
        boost::optional<std::string> theme = response->theme;
        if (moderationEnabled && *moderationEnabled) {
            // सक्षम मॉडरेशन को हैंडल करें
        }
        if (theme) {
            // theme मान का उपयोग करें
        }
    })
    .wait();

getDomainConfigs

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ

प्रतिक्रिया

लौटाता है: 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;
        }
    });

patchDomainConfig

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
domainToUpdate	string	हाँ
patchDomainConfigParams	PatchDomainConfigParams	हाँ

प्रतिक्रिया

लौटाता है: 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) { /* त्रुटि की हैंडलिंग */ }
    });

putDomainConfig

पैरामीटर

नाम	प्रकार	आवश्यक
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) {
    });

createEmailTemplate

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
createEmailTemplateBody	CreateEmailTemplateBody	हाँ

प्रतिक्रिया

रिटर्न करता है: 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;
    });

deleteEmailTemplate

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
id	string	हाँ

प्रतिक्रिया

रिटर्न करता है: APIEmptyResponse

उदाहरण

deleteEmailTemplate उदाहरण

Copy

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

deleteEmailTemplateRenderError

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
errorId	string	हाँ

प्रतिक्रिया

रिटर्न करता है: APIEmptyResponse

उदाहरण

deleteEmailTemplateRenderError उदाहरण

Copy

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

getEmailTemplate

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
id	string	हाँ

प्रतिक्रिया

लौटाता है: GetEmailTemplateResponse

उदाहरण

getEmailTemplate उदाहरण

Copy

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

getEmailTemplateDefinitions

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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;
    }
});

getEmailTemplateRenderErrors

पैरामीटर

नाम	प्रकार	आवश्यक
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) {
            // त्रुटि को संभालें
        }
    });

getEmailTemplates

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
skip	double	नहीं

प्रतिक्रिया

लौटाता है: 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;
    });

renderEmailTemplate

पैरामीटर

नाम	प्रकार	आवश्यक
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";
    });

updateEmailTemplate

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
updateEmailTemplateBody	UpdateEmailTemplateBody	हाँ

प्रतिक्रिया

रिटर्न करता है: APIEmptyResponse

उदाहरण

updateEmailTemplate उदाहरण

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email");
UpdateEmailTemplateBody body;
body.subject = U("Welcome to Our Platform");
body.content = U("<p>Hello \{{userName}}, welcome aboard!</p>");
body.isActive = boost::optional<bool>(true);
api->updateEmailTemplate(tenantId, templateId, body)
    .then([](std::shared_ptr<APIEmptyResponse> response) {
        // सफलता की हैंडलिंग
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception &) { /* त्रुटि की हैंडलिंग */ }
    });

getEventLog

req tenantId urlId userIdWS

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
urlId	string	हाँ
userIdWS	string	हाँ
startTime	int64_t	हाँ
endTime	int64_t	नहीं

प्रतिक्रिया

लौटाता है: GetEventLogResponse

उदाहरण

getEventLog उदाहरण

Copy

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

getGlobalEventLog

req tenantId urlId userIdWS

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
urlId	string	हाँ
userIdWS	string	हाँ
startTime	int64_t	हाँ
endTime	int64_t	नहीं

प्रतिक्रिया

रिटर्न करता है: GetEventLogResponse

उदाहरण

getGlobalEventLog उदाहरण

Copy

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

createFeedPost

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
createFeedPostParams	CreateFeedPostParams	हाँ
options	const CreateFeedPostOptions&	हाँ

प्रतिक्रिया

लौटाता है: 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;
});

createFeedPostPublic

पैरामीटर

नाम	प्रकार	आवश्यक
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;
        }
    });

deleteFeedPostPublic

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
postId	string	हाँ
options	const DeleteFeedPostPublicOptions&	हाँ

प्रतिक्रिया

लौटाता है: 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()) {
            // सफलता का लॉजिक
        }
    });

getFeedPosts

req tenantId afterId

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetFeedPostsOptions&	हाँ

प्रतिक्रिया

लौटाता है: GetFeedPostsResponse

उदाहरण

getFeedPosts उदाहरण

Copy

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

getFeedPostsPublic

req tenantId afterId

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetFeedPostsPublicOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: PublicFeedPostsResponse

उदाहरण

getFeedPostsPublic उदाहरण

Copy

auto options = GetFeedPostsPublicOptions{};
options.limit = boost::optional<int>{20};
options.before = boost::optional<utility::string_t>{U("2023-01-01T00:00:00Z")};
api->getFeedPostsPublic(U("my-tenant-123"), options).then([](pplx::task<std::shared_ptr<PublicFeedPostsResponse>> task){
    try{
        auto response = task.get();
        auto processed = std::make_shared<PublicFeedPostsResponse>(*response);
        // processed का आवश्यकतानुसार उपयोग करें
    }catch(const std::exception&){
        // त्रुटि को संभालें
    }
});

getFeedPostsStats

पैरामीटर

नाम	प्रकार	आवश्यक
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;
    });

getUserReactsPublic

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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();
});

reactFeedPostPublic

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
postId	string	हाँ
reactBodyParams	ReactBodyParams	हाँ
options	const ReactFeedPostPublicOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: ReactFeedPostResponse

उदाहरण

reactFeedPostPublic उदाहरण

Copy

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

updateFeedPost

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
feedPost	FeedPost	हाँ

प्रतिक्रिया

रिटर्न करता है: 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) {
        }
    });

updateFeedPostPublic

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
postId	string	हाँ
updateFeedPostParams	UpdateFeedPostParams	हाँ
options	const UpdateFeedPostPublicOptions&	हाँ

प्रतिक्रिया

लौटाता है: CreateFeedPostResponse

उदाहरण

updateFeedPostPublic उदाहरण

Copy

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

flagCommentPublic

पैरामीटर

नाम	प्रकार	आवश्यक
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&){
        }
    });

getGifLarge

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
largeInternalURLSanitized	string	हाँ

प्रतिक्रिया

लौटाता है: GifGetLargeResponse

उदाहरण

getGifLarge उदाहरण

Copy

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

getGifsSearch

पैरामीटर

नाम	प्रकार	आवश्यक
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&){
    }
});

getGifsTrending

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetGifsTrendingOptions&	हाँ

प्रतिक्रिया

लौटाता है: 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;
    }
});

addHashTag

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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;
    });

addHashTagsBulk

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&){
    }
});

deleteHashTag

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
tag	string	हाँ
deleteHashTagRequestBody	DeleteHashTagRequestBody	हाँ

प्रतिक्रिया

लौटाता है: 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) {
    });

getHashTags

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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);
        // response का उपयोग करें
    } catch (const std::exception&) {
        // त्रुटि को संभालें
    }
});

patchHashTag

पैरामीटर

नाम	प्रकार	आवश्यक
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;
       }
   });

deleteModerationVote

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
voteId	string	हाँ
options	const DeleteModerationVoteOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: 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){});

getApiComments

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetApiCommentsOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: ModerationAPIGetCommentsResponse

उदाहरण

getApiComments उदाहरण

Copy

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

getApiExportStatus

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&){
        }
    });

getApiIds

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetApiIdsOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: 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&){
    }
});

getBanUsersFromComment

पैरामीटर

नाम	प्रकार	आवश्यक
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&) {
    }
});

getCommentBanStatus

पैरामीटर

नाम	प्रकार	आवश्यक
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&){ }
});

getCommentChildren

पैरामीटर

नाम	प्रकार	आवश्यक
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&) {
        }
    });

getCount

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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;
    }
});

getCounts

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
sso	string	नहीं

प्रतिक्रिया

रिटर्न करता है: 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&){
    }
});

getLogs

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
sso	string	नहीं

प्रतिक्रिया

लौटाता है: 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(...){
    }
});

getManualBadges

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
sso	string	नहीं

प्रतिक्रिया

रिटर्न करता है: 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) {
            // त्रुटि को संभालें
        }
    });

getManualBadgesForUser

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetManualBadgesForUserOptions&	हाँ

प्रतिक्रिया

लौटाता है: 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&){
    }
});

getModerationComment

पैरामीटर

नाम	प्रकार	आवश्यक
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) {
            // त्रुटि को संभालें
        }
    });

getModerationCommentText

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
sso	string	नहीं

प्रतिक्रिया

रिटर्न करता है: 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&) {
        }
    });

getPreBanSummary

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
options	const GetPreBanSummaryOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: 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();
            // summary प्रोसेस करें
        } catch (const std::exception&) {
            // त्रुटि संभालें
        }
    });

getSearchCommentsSummary

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&){
    }
});

getSearchPages

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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();
            // response का उपयोग करें
        } catch (const std::exception& e) {
            // त्रुटि को संभालें
        }
    });

getSearchSites

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&) {
           // त्रुटि हैंडलिंग
       }
   });

getSearchSuggest

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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();

getSearchUsers

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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;
        }
    });

getTrustFactor

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetTrustFactorOptions&	हाँ

प्रतिक्रिया

लौटाता है: GetUserTrustFactorResponse

उदाहरण

getTrustFactor उदाहरण

Copy

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

getUserBanPreference

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
sso	string	नहीं

प्रतिक्रिया

लौटाता है: APIModerateGetUserBanPreferencesResponse

उदाहरण

getUserBanPreference उदाहरण

Copy

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

getUserInternalProfile

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetUserInternalProfileOptions&	हाँ

प्रतिक्रिया

लौटाता है: 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;
        }
    });

postAdjustCommentVotes

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
adjustCommentVotesParams	AdjustCommentVotesParams	हाँ
options	const PostAdjustCommentVotesOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: AdjustVotesResponse

उदाहरण

postAdjustCommentVotes उदाहरण

Copy

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

postApiExport

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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();

postBanUserFromComment

पैरामीटर

नाम	प्रकार	आवश्यक
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) {
        // result handling
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* error handling */ }
    });

postBanUserUndo

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
banUserUndoParams	BanUserUndoParams	हाँ
sso	string	नहीं

प्रतिक्रिया

रिटर्न करता है: APIEmptyResponse

उदाहरण

postBanUserUndo उदाहरण

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
BanUserUndoParams banParams;
banParams.userId = utility::string_t(U("user-567"));
banParams.reason = utility::string_t(U("reinstated"));
boost::optional<utility::string_t> sso = utility::string_t(U("sso-token-abc"));
api->postBanUserUndo(tenantId, banParams, sso).then([](std::shared_ptr<APIEmptyResponse> resp){
    // सफलता को हैंडल करें
});

postBulkPreBanSummary

पैरामीटर

नाम	प्रकार	आवश्यक
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;
    });

postCommentsByIds

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentsByIdsParams	CommentsByIdsParams	हाँ
sso	string	नहीं

प्रतिक्रिया

रिटर्न करता है: ModerationAPIChildCommentsResponse

उदाहरण

postCommentsByIds उदाहरण

Copy

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

postFlagComment

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
options	const PostFlagCommentOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: 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&){
        }
    });

postRemoveComment

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
options	const PostRemoveCommentOptions&	हाँ

प्रतिक्रिया

लौटाता है: 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) {
            // त्रुटि को हैंडल करें
        }
    });

postRestoreDeletedComment

पैरामीटर

नाम	प्रकार	आवश्यक
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){
    });

postSetCommentApprovalStatus

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
options	const PostSetCommentApprovalStatusOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: 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) {
        }
    });

postSetCommentReviewStatus

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
options	const PostSetCommentReviewStatusOptions&	हाँ

प्रतिक्रिया

लौटाता है: 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){
        }
    });

postSetCommentSpamStatus

पैरामीटर

नाम	प्रकार	आवश्यक
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&) {}
    });

postSetCommentText

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
setCommentTextParams	SetCommentTextParams	हाँ
options	const PostSetCommentTextOptions&	हाँ

प्रतिक्रिया

लौटाता है: 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&) {}
    });

postUnFlagComment

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
options	const PostUnFlagCommentOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: APIEmptyResponse

उदाहरण

postUnFlagComment उदाहरण

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
PostUnFlagCommentOptions opts;
opts.notifyUser = boost::optional<bool>(true);
api->postUnFlagComment(tenantId, commentId, opts)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // यहाँ प्रोसेसिंग की जा सकती है
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

postVote

पैरामीटर

नाम	प्रकार	आवश्यक
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>("अनुचित सामग्री");
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) {
        }
    });

putAwardBadge

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
badgeId	string	हाँ
options	const PutAwardBadgeOptions&	हाँ

प्रतिक्रिया

लौटाता है: AwardUserBadgeResponse

उदाहरण

putAwardBadge उदाहरण

Copy

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

putCloseThread

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
urlId	string	हाँ
sso	string	नहीं

प्रतिक्रिया

रिटर्न करता है: APIEmptyResponse

उदाहरण

putCloseThread उदाहरण

Copy

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

putRemoveBadge

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
badgeId	string	हाँ
options	const PutRemoveBadgeOptions&	हाँ

प्रतिक्रिया

लौटाता है: 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;
});

putReopenThread

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
urlId	string	हाँ
sso	string	नहीं

प्रतिक्रिया

रिटर्न करता है: APIEmptyResponse

उदाहरण

putReopenThread उदाहरण

Copy

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

setTrustFactor

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&) {
        }
    });

createModerator

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
createModeratorBody	CreateModeratorBody	हाँ

प्रतिक्रिया

लौटाता है: 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) {});

deleteModerator

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
sendEmail	string	नहीं

प्रतिक्रिया

रिटर्न करता है: 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) {
        // सफलता को हैंडल करें
    });

getModerator

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&) {
        }
    });

getModerators

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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();
});

sendInvite

पैरामीटर

नाम	प्रकार	आवश्यक
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) {
    // सफल इनवाइट को हैंडल करें
});

updateModerator

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
updateModeratorBody	UpdateModeratorBody	हाँ

प्रतिक्रिया

लौटाता है: 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&) {} });

deleteNotificationCount

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
id	string	हाँ

प्रतिक्रिया

रिटर्न करता है: APIEmptyResponse

उदाहरण

deleteNotificationCount उदाहरण

Copy

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

getCachedNotificationCount

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&) {
            // त्रुटि संभालें
        }
    });

getNotificationCount

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetNotificationCountOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: GetNotificationCountResponse

उदाहरण

getNotificationCount उदाहरण

Copy

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

getNotifications

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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;
    });

updateNotification

पैरामीटर

नाम	प्रकार	आवश्यक
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>){});

createV1PageReact

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
urlId	string	हाँ
title	string	नहीं

प्रतिक्रिया

रिटर्न करता है: CreateV1PageReact

उदाहरण

createV1PageReact उदाहरण

Copy

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

createV2PageReact

पैरामीटर

नाम	प्रकार	आवश्यक
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&){ }
});

deleteV1PageReact

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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(...){
    }
});

deleteV2PageReact

पैरामीटर

नाम	प्रकार	आवश्यक
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();
    });

getV1PageLikes

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
urlId	string	हाँ

प्रतिक्रिया

लौटाता है: GetV1PageLikes

उदाहरण

getV1PageLikes उदाहरण

Copy

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

getV2PageReacts

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
urlId	string	हाँ

प्रतिक्रिया

रिटर्न करता है: 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 (...) {}
    });

getV2PageReactUsers

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
urlId	string	हाँ
id	string	हाँ

प्रतिक्रिया

लौटाता है: 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&){
        // त्रुटि को संभालें
    }
});

addPage

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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 {
            // त्रुटि को हैंडल करें
        }
    });

deletePage

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
id	string	हाँ

प्रतिक्रिया

रिटर्न करता है: 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) {
           // त्रुटि को संभालें
       }
   });

getOfflineUsers

पेज पर उन पिछले टिप्पणीकारों को जो अभी ऑनलाइन नहीं हैं। displayName के अनुसार क्रमबद्ध। "Members" सेक्शन रेंडर करने के लिए /users/online को पूरा करने के बाद इसका उपयोग करें। commenterName पर कर्सर पेजिनेशन: सर्वर afterName से आगे $gt के माध्यम से आंशिक {tenantId, urlId, commenterName} इंडेक्स को ट्रैवर्स करता है, बिना $skip लागत के।

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
urlId	string	हाँ
options	const GetOfflineUsersOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: PageUsersOfflineResponse

उदाहरण

getOfflineUsers उदाहरण

Copy

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

getOnlineUsers

किसी पेज के वर्तमान में ऑनलाइन दर्शक: वे लोग जिनका websocket सत्र इस समय पेज के लिए सब्सक्राइब है। anonCount + totalCount लौटाता है (पूरे रूम के सब्सक्राइबर, जिनमें वे अनाम दर्शक भी शामिल हैं जिन्हें हम एन्यूमरेट नहीं करते)।

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
urlId	string	हाँ
options	const GetOnlineUsersOptions&	हाँ

प्रतिक्रिया

लौटाता है: 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&){
    }
});

getPageByURLId

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
urlId	string	हाँ

प्रतिक्रिया

रिटर्न करता है: GetPageByURLIdAPIResponse

उदाहरण

getPageByURLId उदाहरण

Copy

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

getPages

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&) {
        }
    });

getPagesPublic

किसी टेनेंट के लिए पेजों की सूची लौटाता है। FChat डेस्कटॉप क्लाइंट द्वारा अपनी रूम सूची भरने के लिए उपयोग किया जाता है। प्रत्येक पेज के लिए रिज़ॉल्व किए गए कस्टम कॉन्फ़िग पर enableFChat true होना आवश्यक है। SSO की आवश्यकता वाले पेजों को अनुरोध करने वाले उपयोगकर्ता के ग्रुप एक्सेस के आधार पर फ़िल्टर किया जाता है।

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetPagesPublicOptions&	हाँ

प्रतिक्रिया

लौटाता है: GetPublicPagesResponse

उदाहरण

getPagesPublic उदाहरण

Copy

utility::string_t tenantId = U("my-tenant-123");
GetPagesPublicOptions options;
options.limit = boost::optional<int>(50);
options.cursor = boost::optional<utility::string_t>(U("cursor-token"));
api->getPagesPublic(tenantId, options).then([](pplx::task<std::shared_ptr<GetPublicPagesResponse>> task){
    try{
        auto response = task.get();
        // आवश्यक हो तो प्रतिक्रिया प्रोसेस करें
    }catch(const std::exception&){
        // आवश्यक हो तो त्रुटि संभालें
    }
});

getUsersInfo

किसी टेनेंट के लिए बल्क यूज़र जानकारी। दिए गए userIds के लिए, User / SSOUser से डिस्प्ले जानकारी लौटाता है। कमेंट विजेट द्वारा उन यूज़र्स को समृद्ध करने के लिए उपयोग किया जाता है जो अभी-अभी एक presence इवेंट के माध्यम से दिखाई दिए। कोई पेज संदर्भ नहीं: गोपनीयता समान रूप से लागू की जाती है (प्राइवेट प्रोफाइल मास्क कर दी जाती हैं)।

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
ids	string	हाँ

प्रतिक्रिया

लौटाता है: PageUsersInfoResponse

उदाहरण

getUsersInfo उदाहरण

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t ids = U("alice@example.com,bob@example.com");
boost::optional<utility::string_t> locale = boost::make_optional(U("en-US"));
api->getUsersInfo(tenantId, ids).then([](pplx::task<std::shared_ptr<PageUsersInfoResponse>> t){
    try{
        auto response = t.get();
        // प्रतिक्रिया प्रोसेस करें
    }catch(const std::exception&){
        // त्रुटि को संभालें
    }
});

patchPage

पैरामीटर

नाम	प्रकार	आवश्यक
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&) {}
    });

deletePendingWebhookEvent

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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) { }
    });

getPendingWebhookEventCount

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetPendingWebhookEventCountOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: 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();
    });

getPendingWebhookEvents

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetPendingWebhookEventsOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: 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&) {}
    });

createQuestionConfig

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&){}
});

deleteQuestionConfig

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
id	string	हाँ

प्रतिक्रिया

रिटर्न करता है: APIEmptyResponse

उदाहरण

deleteQuestionConfig उदाहरण

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto configId = utility::conversions::to_string_t("question-config-456");
api->deleteQuestionConfig(tenantId, configId)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // सफल डिलीशन को हैंडल करें
    })
    .then([](pplx::task<void> t) {
        try {
            t.get();
        } catch (const std::exception&) {
            // त्रुटि को हैंडल करें
        }
    });

getQuestionConfig

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&) {
            // त्रुटि को संभालें
        }
    });

getQuestionConfigs

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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);
});

updateQuestionConfig

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
updateQuestionConfigBody	UpdateQuestionConfigBody	हाँ

प्रतिक्रिया

रिटर्न करता है: APIEmptyResponse

उदाहरण

updateQuestionConfig उदाहरण

Copy

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

createQuestionResult

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&) {
        }
    });

deleteQuestionResult

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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 )
            {
                // त्रुटि की हैंडलिंग
            }
        } );
}

getQuestionResult

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&) {
        }
    });

getQuestionResults

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetQuestionResultsOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: GetQuestionResultsResponse

उदाहरण

getQuestionResults उदाहरण

Copy

utility::string_t tenantId = U("my-tenant-123");
GetQuestionResultsOptions options;
options.questionId = boost::optional<utility::string_t>(U("question-456"));
options.includeDeleted = boost::optional<bool>(false);
api->getQuestionResults(tenantId, options)
    .then([](pplx::task<std::shared_ptr<GetQuestionResultsResponse>> t) {
        auto response = t.get();
        // प्रतिक्रिया को संभालें
    });

updateQuestionResult

पैरामीटर

नाम	प्रकार	आवश्यक
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&) {
        }
    });

aggregateQuestionResults

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const AggregateQuestionResultsOptions&	हाँ

प्रतिक्रिया

लौटाता है: AggregateQuestionResultsResponse

उदाहरण

aggregateQuestionResults उदाहरण

Copy

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

bulkAggregateQuestionResults

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	हाँ
forceRecalculate	bool	नहीं

प्रतिक्रिया

लौटाता है: 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();
   });

combineCommentsWithQuestionResults

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const CombineCommentsWithQuestionResultsOptions&	हाँ

प्रतिक्रिया

लौटाता है: 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&){
        }
    });

addSSOUser

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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) {
    });

deleteSSOUser

पैरामीटर

नाम	प्रकार	आवश्यक
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;
    }
});

getSSOUserByEmail

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
email	string	हाँ

प्रतिक्रिया

रिटर्न करता है: GetSSOUserByEmailAPIResponse

उदाहरण

getSSOUserByEmail उदाहरण

Copy

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

getSSOUserById

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
id	string	हाँ

प्रतिक्रिया

लौटाता है: GetSSOUserByIdAPIResponse

उदाहरण

getSSOUserById उदाहरण

Copy

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

getSSOUsers

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&) {
    }
});

patchSSOUser

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
updateAPISSOUserData	UpdateAPISSOUserData	हाँ
updateComments	bool	नहीं

प्रतिक्रिया

लौटाता है: PatchSSOUserAPIResponse

उदाहरण

patchSSOUser उदाहरण

Copy

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

putSSOUser

पैरामीटर

नाम	प्रकार	आवश्यक
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();
});

createSubscription

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	हाँ

प्रतिक्रिया

रिटर्न करता है: CreateSubscriptionAPIResponse

उदाहरण

createSubscription उदाहरण

Copy

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

deleteSubscription

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
userId	string	नहीं

प्रतिक्रिया

लौटाता है: DeleteSubscriptionAPIResponse

उदाहरण

deleteSubscription उदाहरण

Copy

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

getSubscriptions

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
userId	string	नहीं

प्रतिक्रिया

लौटाता है: 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) {
            // त्रुटि संभालें
        }
    }
);

updateSubscription

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	हाँ
userId	string	नहीं

प्रतिक्रिया

रिटर्न करता है: 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;
});

getTenantDailyUsages

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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();

createTenantPackage

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
createTenantPackageBody	CreateTenantPackageBody	हाँ

प्रतिक्रिया

लौटाता है: CreateTenantPackageResponse

उदाहरण

createTenantPackage उदाहरण

Copy

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

deleteTenantPackage

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&){ } });

getTenantPackage

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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(...){}
});

getTenantPackages

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
skip	double	नहीं

प्रतिक्रिया

रिटर्न करता है: GetTenantPackagesResponse

उदाहरण

getTenantPackages उदाहरण

Copy

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

replaceTenantPackage

पैरामीटर

नाम	प्रकार	आवश्यक
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&) { }
    });

updateTenantPackage

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
updateTenantPackageBody	UpdateTenantPackageBody	हाँ

प्रतिक्रिया

रिटर्न करता है: APIEmptyResponse

उदाहरण

updateTenantPackage उदाहरण

Copy

auto body = std::make_shared<UpdateTenantPackageBody>();
body->packageId = utility::conversions::to_string_t("premium-plan");
body->expirationDate = utility::conversions::to_string_t("2025-12-31");
body->notes = boost::optional<utility::string_t>(utility::conversions::to_string_t("Upgraded package"));
api->updateTenantPackage(utility::conversions::to_string_t("my-tenant-123"),
                         utility::conversions::to_string_t("pkg-456"),
                         body)
    .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> task) {
        try {
            auto response = task.get();
            // सफलता का प्रबंधन
        } catch (const std::exception& ex) {
            // त्रुटि का प्रबंधन
        }
    });

createTenantUser

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
createTenantUserBody	CreateTenantUserBody	हाँ

प्रतिक्रिया

रिटर्न करता है: CreateTenantUserResponse

उदाहरण

createTenantUser उदाहरण

Copy

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

deleteTenantUser

पैरामीटर

नाम	प्रकार	आवश्यक
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;
    });

getTenantUser

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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();
            // आवश्यकतानुसार response का उपयोग करें
        } catch (const std::exception&) {
            // त्रुटि हैंडलिंग
        }
    });

getTenantUsers

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&) {
    }
});

replaceTenantUser

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
replaceTenantUserBody	ReplaceTenantUserBody	हाँ
updateComments	string	नहीं

प्रतिक्रिया

लौटाता है: 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){ });

sendLoginLink

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
redirectURL	string	नहीं

प्रतिक्रिया

लौटाता है: 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) {
});

updateTenantUser

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
updateTenantUserBody	UpdateTenantUserBody	हाँ
updateComments	string	नहीं

प्रतिक्रिया

रिटर्न करता है: APIEmptyResponse

उदाहरण

updateTenantUser उदाहरण

Copy

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

createTenant

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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();
});

deleteTenant

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
sure	string	नहीं

प्रतिक्रिया

रिटर्न करता है: APIEmptyResponse

उदाहरण

deleteTenant उदाहरण

Copy

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

getTenant

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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;
        }
    });

getTenants

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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(...){} });

updateTenant

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
updateTenantBody	UpdateTenantBody	हाँ

प्रतिक्रिया

रिटर्न करता है: 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;
});

changeTicketState

पैरामीटर

नाम	प्रकार	आवश्यक
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>) {});

createTicket

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
userId	string	हाँ
createTicketBody	CreateTicketBody	हाँ

प्रतिक्रिया

लौटाता है: CreateTicketResponse

उदाहरण

createTicket उदाहरण

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("john.doe@example.com");
CreateTicketBody ticketBody;
ticketBody.setSubject(utility::conversions::to_string_t("Login Issue"));
ticketBody.setDescription(utility::conversions::to_string_t("Cannot log in after password reset."));
boost::optional<int> priority = 2;
ticketBody.setPriority(priority);
api->createTicket(tenantId, userId, ticketBody).then([](pplx::task<std::shared_ptr<CreateTicketResponse>> task){
    try{
        auto response = task.get();
        // प्रतिक्रिया का आवश्यकतानुसार उपयोग करें
    }catch(const std::exception&){
        // त्रुटि को संभालें
    }
});

getTicket

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
userId	string	नहीं

प्रतिक्रिया

लौटाता है: GetTicketResponse

उदाहरण

getTicket उदाहरण

Copy

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

getTickets

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetTicketsOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: 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&) {
    }
});

getTranslations

पैरामीटर

नाम	प्रकार	आवश्यक
r_namespace	string	हाँ
component	string	हाँ
options	const GetTranslationsOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: GetTranslationsResponse

उदाहरण

getTranslations उदाहरण

Copy

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

uploadImage

एक इमेज अपलोड और रिसाइज़ करें

पैरामीटर

नाम	प्रकार	आवश्यक
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();
});

getUserBadgeProgressById

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
id	string	हाँ

प्रतिक्रिया

रिटर्न करता है: APIGetUserBadgeProgressResponse

उदाहरण

getUserBadgeProgressById उदाहरण

Copy

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

getUserBadgeProgressByUserId

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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;
        }
    });

getUserBadgeProgressList

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetUserBadgeProgressListOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: APIGetUserBadgeProgressListResponse

उदाहरण

getUserBadgeProgressList उदाहरण

Copy

utility::string_t tenantId = U("my-tenant-123");
GetUserBadgeProgressListOptions options;
options.userId = U("user@example.com");
options.page = boost::optional<int>(1);
options.pageSize = boost::optional<int>(20);
api->getUserBadgeProgressList(tenantId, options)
    .then([](std::shared_ptr<APIGetUserBadgeProgressListResponse> resp) {
        if (!resp) return;
        for (const auto& badge : resp->badges) {
            // बैज प्रोसेस करें
        }
    });

createUserBadge

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
createUserBadgeParams	CreateUserBadgeParams	हाँ

प्रतिक्रिया

लौटाता है: APICreateUserBadgeResponse

उदाहरण

createUserBadge उदाहरण

Copy

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

deleteUserBadge

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&){ }
    });

getUserBadge

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&){
    }
});

getUserBadges

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetUserBadgesOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: 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&) {
       }
   });

updateUserBadge

पैरामीटर

नाम	प्रकार	आवश्यक
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";
    });

getUserNotificationCount

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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&){
        // त्रुटि को संभालें
    }
});

getUserNotifications

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const GetUserNotificationsOptions&	हाँ

प्रतिक्रिया

लौटाता है: GetMyNotificationsResponse

उदाहरण

getUserNotifications उदाहरण

Copy

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

resetUserNotificationCount

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
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){
});

resetUserNotifications

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
options	const ResetUserNotificationsOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: 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) {
        // प्रतिक्रिया प्रोसेस करें
    });

updateUserNotificationCommentSubscriptionStatus

किसी विशिष्ट कमेंट के लिए नोटिफिकेशन सक्षम या अक्षम करें।

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
notificationId	string	हाँ
optedInOrOut	string	हाँ
commentId	string	हाँ
sso	string	नहीं

प्रतिक्रिया

रिटर्न करता है: 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;
});

updateUserNotificationPageSubscriptionStatus

किसी पेज के लिए नोटिफिकेशन सक्षम या अक्षम करें। जब उपयोगकर्ता किसी पेज की सदस्यता लेते हैं, तो नए रूट कमेंट्स के लिए नोटिफिकेशन बनाए जाते हैं, और साथ ही

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
urlId	string	हाँ
url	string	हाँ
pageTitle	string	हाँ
subscribedOrUnsubscribed	string	हाँ
sso	string	नहीं

प्रतिक्रिया

रिटर्न: 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 प्रोसेस करें
    });

updateUserNotificationStatus

पैरामीटर

नाम	प्रकार	आवश्यक
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();

getUserPresenceStatuses

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
urlIdWS	string	हाँ
userIds	string	हाँ

प्रतिक्रिया

रिटर्न करता है: GetUserPresenceStatusesResponse

उदाहरण

getUserPresenceStatuses उदाहरण

Copy

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

searchUsers

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
urlId	string	हाँ
options	const SearchUsersOptions&	हाँ

प्रतिक्रिया

लौटाता है: SearchUsersResult

उदाहरण

searchUsers उदाहरण

Copy

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

getUser

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
id	string	हाँ

प्रतिक्रिया

रिटर्न करता है: 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&) {
            // त्रुटि को संभालें
        }
    });

createVote

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
commentId	string	हाँ
direction	string	हाँ
options	const CreateVoteOptions&	हाँ

प्रतिक्रिया

रिटर्न करता है: VoteResponse

उदाहरण

createVote उदाहरण

Copy

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

deleteVote

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
id	string	हाँ
editKey	string	नहीं

प्रतिक्रिया

रिटर्न करता है: VoteDeleteResponse

उदाहरण

deleteVote उदाहरण

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto voteId = utility::conversions::to_string_t("vote-9876");
boost::optional<utility::string_t> editKey = utility::conversions::to_string_t("edit-abc123");
api->deleteVote(tenantId, voteId, editKey).then([](pplx::task<std::shared_ptr<VoteDeleteResponse>> task) {
    try {
        auto response = task.get();
        // प्रतिक्रिया को आवश्यकतानुसार प्रोसेस करें
    } catch (const std::exception&) {
        // त्रुटि को संभालें
    }
});

getVotes

पैरामीटर

नाम	प्रकार	आवश्यक	विवरण
tenantId	string	हाँ
urlId	string	हाँ

प्रतिक्रिया

रिटर्न करता है: 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 (...) {
        // त्रुटि प्रबंधन
    }
});

getVotesForUser

पैरामीटर

नाम	प्रकार	आवश्यक
tenantId	string	हाँ
urlId	string	हाँ
options	const GetVotesForUserOptions&	हाँ

प्रतिक्रिया

लौटाता है: GetVotesForUserResponse

उदाहरण

getVotesForUser उदाहरण

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto urlId = utility::string_t(U("post-456"));
GetVotesForUserOptions options;
options.page = boost::optional<int>(2);
options.pageSize = boost::optional<int>(50);
api->getVotesForUser(tenantId, urlId, options).then([](std::shared_ptr<GetVotesForUserResponse> response) {
    if (response) {
        // प्रतिक्रिया संभालें, जैसे, वोट्स पर पुनरावृति करें
    }
});

सहायता चाहिए?

यदि आपको C++ SDK के बारे में कोई समस्या आती है या कोई प्रश्न है, तो कृपया:

योगदान देना

योगदान का स्वागत है! कृपया योगदान दिशानिर्देशों के लिए GitHub रिपॉजिटरी देखें।

भाषा 🇮🇳 हिन्दी

दस्तावेज़ीकरण

शुरू करें

API संदर्भ

उपयोग

एग्रीगेट

ऑडिट लॉग

प्रमाणीकरण

कमेंट से ब्लॉक

ब्लॉक किए गए कमेंट जांचें

कमेंट्स

उपयोगकर्ता के लिए कमेंट्स

डोमेन कॉन्फ़िग

ईमेल टेम्पलेट

इवेंट लॉग

फ़ीड पोस्ट

कमेंट फ़्लैग करें

GIFs

हैश टैग

मॉडरेशन

मॉडरेटर

सूचना संख्या

सूचनाएं

पेज रिएक्ट

पेज

लंबित वेबहुक इवेंट

प्रश्न कॉन्फ़िग

प्रश्न परिणाम

प्रश्न परिणाम एग्रीगेशन

SSO उपयोगकर्ता

सदस्यताएं

टेनेंट दैनिक उपयोग

टेनेंट पैकेज

टेनेंट उपयोगकर्ता

टेनेंट

टिकट

अनुवाद

छवि अपलोड करें

उपयोगकर्ता बैज प्रगति

उपयोगकर्ता बैज

उपयोगकर्ता सूचनाएं

उपयोगकर्ता उपस्थिति स्थिति

उपयोगकर्ता खोज

उपयोगकर्ता

वोट

FastComments C++ SDK

रिपॉज़िटरी

AI coding agents

Requirements

Installation

डिपेंडेंसीज़ इंस्टॉल करें

सोर्स से बिल्ड करना

इंस्टॉल करना

लाइब्रेरी सामग्री

पब्लिक बनाम सिक्योर्ड API

Quick Start

प्रमाणित APIs का उपयोग (DefaultAPI)

सार्वजनिक APIs का उपयोग (PublicAPI)

मॉडरेशन APIs का उपयोग (ModerationApi)

सामान्य समस्याएँ

Making API Calls: Synchronous vs Asynchronous

.get() के साथ सिंक्रोनस कॉल्स

.then() के साथ एसिंक्रोनस कॉल्स

सिंक्रोनस और एसिंक्रोनस में से चुनाव

Notes

ब्रॉडकास्ट आईडी

SSO (सिंगल साइन-ऑन)

SSO Usage

सरल SSO

सुरक्षित SSO

Documentation for fastcomments

Documentation for API Endpoints

Documentation for Models

Documentation for Authorization

api_key

aggregate

पैरामीटर

प्रतिक्रिया

उदाहरण

getAuditLogs

`.get()` के साथ सिंक्रोनस कॉल्स

`.then()` के साथ एसिंक्रोनस कॉल्स