FastComments C++ SDK

Αυτό είναι το επίσημο SDK C++ για το FastComments.

Επίσημο SDK C++ για το API του FastComments

Αποθετήριο

Πράκτορες κώδικα AI

Δώστε στον πράκτορα κώδικά σας το πλαίσιο FastComments που χρειάζεται - widgets, configuration, Secure SSO, το REST API και τα SDKs:

npx skills add fastcomments/skills

Λειτουργεί με το Claude Code, Codex, Cursor, Copilot, Gemini και κάθε άλλο πράκτορα που υποστηρίζει το skills CLI.

Απαιτήσεις

C++17 ή νεότερο
CMake 3.14 ή νεότερο
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (κατεβαίνει αυτόματα για δοκιμές)

Εγκατάσταση

Εγκατάσταση Εξαρτήσεων

sudo apt install libcpprest-dev libboost-all-dev

Κατασκευή από Πηγή

mkdir build
cd build
cmake ..
make

Εγκατάσταση

sudo make install

Περιεχόμενα Βιβλιοθήκης

Αυτή η βιβλιοθήκη περιέχει τον παραγόμενο πελάτη API και τα εργαλεία SSO για να διευκολύνει την εργασία με το API.

API Client Library Docs

Δημόσια vs Ασφαλή API

Για τον πελάτη API, υπάρχουν τρεις κλάσεις, `DefaultApi`, `PublicApi` και `ModerationApi`. Η `DefaultApi` περιλαμβάνει μεθόδους που απαιτούν το κλειδί API σας, ενώ η `PublicApi` περιλαμβάνει μεθόδους που μπορούν να κληθούν απευθείας από έναν περιηγητή/συσκευή κινητής τηλεφωνίας κ.λπ. χωρίς έλεγχο ταυτότητας. Η `ModerationApi` προσφέρει ένα εκτενές σύνολο ζωντανών και γρήγορων APIs διαχείρισης. Κάθε μέθοδος της `ModerationApi` δέχεται μια παράμετρο `sso` και μπορεί να πιστοποιηθεί μέσω SSO ή μέσω cookie συνεδρίας FastComments.com.

Γρήγορη εκκίνηση

Χρήση Πιστοποιημένων API (DefaultAPI)

Σημαντικό:

Πρέπει να ορίσετε τη βασική διεύθυνση URL (ο δημιουργός cpp‑restsdk δεν τη διαβάζει από το OpenAPI spec)
Πρέπει να ορίσετε το κλειδί API σας στο ApiClient πριν κάνετε κλήσεις που απαιτούν πιστοποίηση. Εάν δεν το κάνετε, οι κλήσεις θα αποτύχουν με σφάλμα 401.

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

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

    // ΑΠΑΙΤΙΤΑΙ: Ορίστε τη βασική διεύθυνση URL (επιλέξτε την περιοχή σας)
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));  // US
    // Ή: config->setBaseUrl(utility::conversions::to_string_t("https://eu.fastcomments.com"));  // EU

    // ΑΠΑΙΤΙΤΑΙ: Ορίστε το κλειδί API σας
    config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_API_KEY_HERE"));

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

    // Τώρα κάντε κλήσεις API με πιστοποίηση
    return 0;
}

Χρήση Δημόσιων API (PublicAPI)

Τα δημόσια σημεία τέλους δεν απαιτούν πιστοποίηση:

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

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

    // ΑΠΑΙΤΙΤΑΙ: Ορίστε τη βασική διεύθυνση URL
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

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

    // Κάντε δημόσιες κλήσεις API
    return 0;
}

Χρήση API Συντονισμού (ModerationApi)

Το ModerationApi τροφοδοτεί τον πίνακα ελέγχου του συντονιστή. Κάθε μέθοδος δέχεται μια παράμετρο sso ώστε η κλήση να εκτελείται εκ μέρους ενός συντονιστή που έχει πιστοποιηθεί μέσω SSO (δείτε την ενότητα SSO παρακάτω για το πώς να δημιουργήσετε ένα διακριτικό):

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

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

    // ΑΠΑΙΤΙΤΑΙ: Ορίστε τη βασική διεύθυνση URL
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

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

    // Πραγματοποιήστε κλήση με το SSO διακριτικό του συντονιστή για πιστοποίηση
    auto ssoToken = utility::conversions::to_string_t("YOUR_MODERATOR_SSO_TOKEN");

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

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

    return 0;
}

Κοινά Προβλήματα

Σφάλμα “URI must contain a hostname”: Βεβαιωθείτε ότι έχετε καλέσει config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) πριν δημιουργήσετε το ApiClient. Ο δημιουργός cpp‑restsdk δεν διαβάζει αυτόματα τη διεύθυνση του server από το OpenAPI spec.
Σφάλμα 401 “missing‑api‑key”: Βεβαιωθείτε ότι έχετε καλέσει config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) πριν δημιουργήσετε την περίπτωση DefaultAPI.
Λανθασμένη κλάση API: Χρησιμοποιήστε DefaultApi για κλήσεις εξυπηρετητή με πιστοποίηση, PublicApi για κλήσεις πελάτη/δημόσιες, και ModerationApi για κλήσεις πίνακα ελέγχου συντονιστή (πιστοποιημένες με διακριτικό SSO του συντονιστή).

Κλήσεις API: Συγχρονικές vs Ασύγχρονες

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

Συγχρονικές κλήσεις με `.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);

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

// Call .get() to block and get the result synchronously
auto response = api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    options
).get();  // Μπλοκάρει μέχρι να ολοκληρωθεί το αίτημα HTTP

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

Ασύγχρονες κλήσεις με `.then()`

Χρησιμοποιήστε το .then() για μη-μπλοκαριστική ασύγχρονη εκτέλεση με callbacks:

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

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

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

// Use .then() for asynchronous callback-based execution
api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    options
).then([](std::shared_ptr<GetComments_200_response> response) {
    // Αυτό εκτελείται ασύγχρονα όταν ολοκληρωθεί το αίτημα
    if (response && response->comments) {
        std::cout << "Found " << response->comments->size() << " comments" << std::endl;
    }
});

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

Επιλογή μεταξύ Συγχρονισμού και Ασύγχρονης Εκτέλεσης

Η επιλογή εξαρτάται από το περιβάλλον εκτέλεσης και την αρχιτεκτονική της εφαρμογής σας:

.get() (Synchronous blocking)

Μπλοκάρει το νήμα που καλεί μέχρι να ολοκληρωθεί το αίτημα HTTP
Απλούστερη ροή κώδικα, πιο εύκολο να λογιστεί κανείς
Κατάλληλο για αποκλειστικά νήματα εργασίας, επεξεργασία παρτίδων ή εργαλεία γραμμής εντολών
Μη κατάλληλο για βρόχους γεγονότων, νήματα GUI ή εξυπηρετητές μονής λειτουργίας

.then() (Asynchronous non-blocking)

Επιστρέφει άμεσα, η callback εκτελείται όταν ολοκληρωθεί το αίτημα
Δεν μπλοκάρει το νήμα που καλεί
Απαιτείται για αρχιτεκτονικές βάσει γεγονότων, εφαρμογές GUI ή βρόχους γεγονότων μονής λειτουργίας
Επιτρέπει την αθροίωση πολλαπλών λειτουργιών
Πιο σύνθετη ροή ελέγχου

Η σειρά δοκιμών του SDK χρησιμοποιεί αποκλειστικά το .get(), αλλά αυτό είναι κατάλληλο για το περιβάλλον δοκιμών όπου η μπλοκάρισμα είναι αποδεκτή.

Σημειώσεις

Αναγνωριστικά Broadcast

Θα δείτε ότι πρέπει να περάσετε ένα broadcastId σε ορισμένες κλήσεις API. Όταν λαμβάνετε συμβάντα, θα λάβετε αυτό το ID πίσω, ώστε να ξέρετε να αγνοήσετε το συμβάν αν σκοπεύετε να εφαρμόσετε τις αλλαγές αισιόδοξα στην πλευρά του client (που πιθανότατα θα θελήσετε να κάνετε καθώς προσφέρει την καλύτερη εμπειρία). Περάστε εδώ ένα UUID. Το ID θα πρέπει να είναι αρκετά μοναδικό ώστε να μην εμφανιστεί δύο φορές σε μια συνεδρία περιηγητή.

SSO (Ενιαία Σύνδεση)

Για παραδείγματα SSO, δείτε παρακάτω.

Χρήση SSO

Απλό SSO

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

using namespace fastcomments::sso;

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

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

Ασφαλές SSO

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

using namespace fastcomments::sso;

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

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

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

Τεκμηρίωση για fastcomments

Documentation for API Endpoints

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

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

Documentation for Models

Documentation for Authorization

api_key

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

Σύνολο

Συγκεντρώνει έγγραφα ομαδοποιώντας τα (εάν παρέχεται το groupBy) και εφαρμόζοντας πολλαπλές λειτουργίες. Υποστηρίζονται διαφορετικές λειτουργίες (π.χ. sum, countDistinct, avg κ.λπ.).

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
aggregationRequest	AggregationRequest	Yes
options	const AggregateOptions&	Yes

Απόκριση

Επιστρέφει: AggregateResponse

Παράδειγμα

Παράδειγμα Συγκεντρωσης

Copy

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

Λήψη αρχείων ελέγχου

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
options	const GetAuditLogsOptions&	Yes

Απάντηση

Returns: GetAuditLogsResponse

Παράδειγμα

Παράδειγμα getAuditLogs

Copy

utility::string_t tenantId = U("my-tenant-123");
GetAuditLogsOptions options;
options.startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-01T00:00:00Z"), utility::datetime::RFC_1123));
options.endDate   = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-31T23:59:59Z"), utility::datetime::RFC_1123));
options.limit     = boost::optional<int>(100);
api->getAuditLogs(tenantId, options).then([](pplx::task<std::shared_ptr<GetAuditLogsResponse>> t) {
    try {
        auto response = t.get();
        // χρήση απόκρισης
    } catch (const std::exception& e) {
        // διαχείριση σφάλματος
    }
});

Δημόσια αποσύνδεση

Απάντηση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

logoutPublic Παράδειγμα

Copy

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

Δημόσιος αποκλεισμός από σχόλιο

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
commentId	string	Yes
publicBlockFromCommentParams	PublicBlockFromCommentParams	Yes
sso	string	No

Απόκριση

Επιστρέφει: BlockSuccess

Παράδειγμα

blockFromCommentPublic Παράδειγμα

Copy

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

Δημόσια άρση αποκλεισμού σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
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){ });

Ελεγμένα σχόλια για αποκλεισμό

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
commentIds	string	Yes
sso	string	No

Απάντηση

Επιστρέφει: CheckBlockedCommentsResponse

Παράδειγμα

checkedCommentsForBlocked Παράδειγμα

Copy

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

Αποκλεισμός χρήστη από σχόλιο

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
id	string	Yes
blockFromCommentParams	BlockFromCommentParams	Yes
options	const BlockUserFromCommentOptions&	Yes

Απάντηση

Επιστρέφει: BlockSuccess

Παράδειγμα

Παράδειγμα blockUserFromComment

Copy

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

Δημιουργία δημόσιου σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
commentData	CommentData	Yes
options	const CreateCommentPublicOptions&	Yes

Απάντηση

Επιστρέφει: SaveCommentsResponseWithPresence

Παράδειγμα

createCommentPublic Παράδειγμα

Copy

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

Διαγραφή σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
id	string	Ναι
options	const DeleteCommentOptions&	Ναι

Απόκριση

Επιστρέφει: DeleteCommentResult

Παράδειγμα

deleteComment Παράδειγμα

Copy

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

Δημόσια διαγραφή σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
commentId	string	Ναι
broadcastId	string	Ναι
options	const DeleteCommentPublicOptions&	Ναι

Απόκριση

Επιστρέφει: PublicAPIDeleteCommentResponse

Παράδειγμα

Παράδειγμα deleteCommentPublic

Copy

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

Διαγραφή ψήφου σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
commentId	string	Ναι
voteId	string	Ναι
urlId	string	Ναι
broadcastId	string	Ναι
options	const DeleteCommentVoteOptions&	Ναι

Απάντηση

Επιστρέφει: VoteDeleteResponse

Παράδειγμα

deleteCommentVote Παράδειγμα

Copy

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

Σημείωση σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
id	string	Ναι
options	const FlagCommentOptions&	Ναι

Απόκριση

Επιστρέφει: FlagCommentResponse

Παράδειγμα

flagComment Παράδειγμα

Copy

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

Λήψη σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
id	string	Ναι

Απάντηση

Επιστρέφει: APIGetCommentResponse

Παράδειγμα

Παράδειγμα getComment

Copy

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

Λήψη σχολίων

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
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();
        // use response as needed
    } catch (const std::exception& e) {
        // handle error
    }
});

Δημόσια λήψη σχολίων

req tenantId urlId

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
urlId	string	Yes
options	const GetCommentsPublicOptions&	Yes

Απόκριση

Επιστρέφει: GetCommentsResponseWithPresence_PublicComment_

Παράδειγμα

Παράδειγμα getCommentsPublic

Copy

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

Λήψη κειμένου σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
commentId	string	Ναι
options	const GetCommentTextOptions&	Ναι

Απόκριση

Επιστρέφει: PublicAPIGetCommentTextResponse

Παράδειγμα

Παράδειγμα getCommentText

Copy

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

Λήψη ονομάτων χρηστών ψήφου σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
commentId	string	Ναι
dir	int32_t	Ναι
sso	string	Όχι

Απάντηση

Επιστρέφει: GetCommentVoteUserNamesSuccessResponse

Παράδειγμα

Παράδειγμα getCommentVoteUserNames

Copy

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

Κλείδωμα σχολίου

Παραμέτρους

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
commentId	string	Ναι
broadcastId	string	Ναι
sso	string	Όχι

Απόκριση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

Παράδειγμα lockComment

Copy

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

Καρφίτσωμα σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Απόκριση

Επιστρέφει: ChangeCommentPinStatusResponse

Παράδειγμα

Παράδειγμα pinComment

Copy

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

Αποθήκευση σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
createCommentParams	CreateCommentParams	Yes
options	const SaveCommentOptions&	Yes

Απόκριση

Επιστρέφει: APISaveCommentResponse

Παράδειγμα

saveComment Παράδειγμα

Copy

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

Ορισμός κειμένου σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
commentTextUpdateRequest	CommentTextUpdateRequest	Yes
options	const SetCommentTextOptions&	Yes

Απόκριση

Επιστρέφει: PublicAPISetCommentTextResponse

Παράδειγμα

setCommentText Παράδειγμα

Copy

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

Άρση αποκλεισμού χρήστη από σχόλιο

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
id	string	Ναι
unBlockFromCommentParams	UnBlockFromCommentParams	Ναι
options	const UnBlockUserFromCommentOptions&	Ναι

Απάντηση

Returns: UnblockSuccess

Παράδειγμα

Παράδειγμα unBlockUserFromComment

Copy

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

Αναίρεση σημείωσης σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
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;
            // επεξεργαστείτε την κατάσταση εάν χρειάζεται
        }
    })
    .then([](pplx::task<void> previous) {
        try {
            previous.get();
        } catch (const std::exception& e) {
            // διαχειριστείτε το σφάλμα
        }
    });

Ξεκλείδωμα σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Απάντηση

Επιστρέφει: 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&) {
    }
});

Αφαίρεση καρφιτσώματος σχολίου

Παράμετροι

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

Απάντηση

Επιστρέφει: 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);
});

Ενημέρωση σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
id	string	Yes
updatableCommentParams	UpdatableCommentParams	Yes
options	const UpdateCommentOptions&	Yes

Απόκριση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

Παράδειγμα updateComment

Copy

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

Ψήφος σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
commentId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
voteBodyParams	VoteBodyParams	Yes
options	const VoteCommentOptions&	Yes

Απάντηση

Επιστρέφει: VoteResponse

Παράδειγμα

Παράδειγμα voteComment

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-7890");
auto urlId = utility::conversions::to_string_t("article-456");
auto broadcastId = utility::conversions::to_string_t("broadcast-321");
VoteBodyParams voteParams;
voteParams.upvote = true;
voteParams.note = boost::optional<utility::string_t>(utility::conversions::to_string_t("Great insight"));
VoteCommentOptions options;
options.dryRun = boost::optional<bool>(false);
api->voteComment(tenantId, commentId, urlId, broadcastId, voteParams, options)
   .then([](pplx::task<std::shared_ptr<VoteResponse>> t) {
       try {
           auto response = t.get();
           // επεξεργασία απάντησης
       } catch (const std::exception&) {
       }
   });

Λήψη σχολίων για χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
options	const GetCommentsForUserOptions&	Ναι

Απάντηση

Επιστρέφει: GetCommentsForUserResponse

Παράδειγμα

Παράδειγμα getCommentsForUser

Copy

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

Προσθήκη ρύθμισης τομέα

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
addDomainConfigParams	AddDomainConfigParams	Yes

Απόκριση

Επιστρέφει: AddDomainConfigResponse

Παράδειγμα

addDomainConfig Παράδειγμα

Copy

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

Διαγραφή ρύθμισης τομέα

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
domain	string	Ναι

Απάντηση

Επιστρέφει: DeleteDomainConfigResponse

Παράδειγμα

Παράδειγμα deleteDomainConfig

Copy

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

Λήψη ρύθμισης τομέα

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
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) {
            // χειρισμός ενεργοποιημένου moderation
        }
        if (theme) {
            // χρήση τιμής theme
        }
    })
    .wait();

Λήψη ρυθμίσεων τομέα

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes

Απόκριση

Επιστρέφει: GetDomainConfigsResponse

Παράδειγμα

Παράδειγμα getDomainConfigs

Copy

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

Διόρθωση ρύθμισης τομέα

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
domainToUpdate	string	Yes
patchDomainConfigParams	PatchDomainConfigParams	Yes

Απάντηση

Επιστρέφει: PatchDomainConfigResponse

Παράδειγμα

patchDomainConfig Παράδειγμα

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto domainToUpdate = utility::conversions::to_string_t("example.com");
PatchDomainConfigParams patchDomainConfigParams;
patchDomainConfigParams.enableComments = boost::optional<bool>(true);
patchDomainConfigParams.moderationLevel = boost::optional<int>(2);
patchDomainConfigParams.customHeader = boost::optional<utility::string_t>(utility::conversions::to_string_t("X-Custom-Header"));
api->patchDomainConfig(tenantId, domainToUpdate, patchDomainConfigParams)
    .then([](std::shared_ptr<PatchDomainConfigResponse> resp) {
        // διαχείριση επιτυχίας
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* διαχείριση σφάλματος */ }
    });

Αντικατάσταση ρύθμισης τομέα

Parameters

Όνομα	Τύπος	Απαιτείται
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) {
    });

Δημιουργία προτύπου email

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
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;
    });

Διαγραφή προτύπου email

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
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&) {}
    });

Διαγραφή σφάλματος απόδοσης προτύπου email

Παράμετροι

Όνομα	Τύπος	Απαιτείται
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 (...) {}
    });

Λήψη προτύπου email

Παράμετροι

Name	Type	Required	Description
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&) {
        }
    });

Λήψη ορισμών προτύπου email

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
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;
    }
});

Λήψη σφαλμάτων απόδοσης προτύπου email

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
id	string	Yes
skip	double	No

Απόκριση

Επιστρέφει: 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) {
            // Διαχειριστείτε το σφάλμα
        }
    });

Λήψη προτύπων email

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
skip	double	No

Απόκριση

Επιστρέφει: GetEmailTemplatesResponse

Παράδειγμα

Παράδειγμα getEmailTemplates

Copy

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

Απόδοση προτύπου email

Παράμετροι

Όνομα	Τύπος	Απαιτούμενο
tenantId	string	Yes
renderEmailTemplateBody	RenderEmailTemplateBody	Yes
locale	string	No

Απάντηση

Επιστρέφει: 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";
    });

Ενημέρωση προτύπου email

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
id	string	Yes
updateEmailTemplateBody	UpdateEmailTemplateBody	Yes

Απάντηση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

Παράδειγμα updateEmailTemplate

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email");
UpdateEmailTemplateBody body;
body.subject = U("Welcome to Our Platform");
body.content = U("<p>Hello \{{userName}}, welcome aboard!</p>");
body.isActive = boost::optional<bool>(true);
api->updateEmailTemplate(tenantId, templateId, body)
    .then([](std::shared_ptr<APIEmptyResponse> response) {
        // διαχείριση επιτυχίας
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception &) { /* διαχείριση σφάλματος */ }
    });

Λήψη αρχείου συμβάντων

req tenantId urlId userIdWS

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
urlId	string	Yes
userIdWS	string	Yes
startTime	int64_t	Yes
endTime	int64_t	No

Απάντηση

Επιστρέφει: GetEventLogResponse

Παράδειγμα

Παράδειγμα getEventLog

Copy

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

Λήψη παγκόσμιου αρχείου συμβάντων

req tenantId urlId userIdWS

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
urlId	string	Ναι
userIdWS	string	Ναι
startTime	int64_t	Ναι
endTime	int64_t	Όχι

Απάντηση

Επιστρέφει: GetEventLogResponse

Παράδειγμα

Παράδειγμα getGlobalEventLog

Copy

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

Δημιουργία δημοσίευσης ροής

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
options	const CreateFeedPostOptions&	Yes

Απάντηση

Επιστρέφει: CreateFeedPostsResponse

Παράδειγμα

Παράδειγμα createFeedPost

Copy

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

Δημόσια δημιουργία δημοσίευσης ροής

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
options	const CreateFeedPostPublicOptions&	Yes

Απάντηση

Επιστρέφει: CreateFeedPostResponse

Παράδειγμα

createFeedPostPublic Παράδειγμα

Copy

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

Δημόσια διαγραφή δημοσίευσης ροής

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
postId	string	Yes
options	const DeleteFeedPostPublicOptions&	Yes

Απάντηση

Επιστρέφει: DeleteFeedPostPublicResponse

Παράδειγμα

deleteFeedPostPublic Παράδειγμα

Copy

auto opts = std::make_shared<DeleteFeedPostPublicOptions>();
opts->reason = boost::optional<utility::string_t>(U("Inappropriate content"));
api->deleteFeedPostPublic(U("my-tenant-123"), U("post-789"), *opts)
    .then([](std::shared_ptr<DeleteFeedPostPublicResponse> resp) {
        if (resp && resp->isSuccess()) {
            // λογική επιτυχίας
        }
    });

Λήψη δημοσιεύσεων ροής

req tenantId afterId

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
options	const GetFeedPostsOptions&	Ναι

Απόκριση

Επιστρέφει: GetFeedPostsResponse

Παράδειγμα

Παράδειγμα getFeedPosts

Copy

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

Δημόσια λήψη δημοσιεύσεων ροής

req tenantId afterId

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
options	const GetFeedPostsPublicOptions&	Ναι

Απάντηση

Επιστρέφει: PublicFeedPostsResponse

Παράδειγμα

getFeedPostsPublic Παράδειγμα

Copy

auto options = GetFeedPostsPublicOptions{};
options.limit = boost::optional<int>{20};
options.before = boost::optional<utility::string_t>{U("2023-01-01T00:00:00Z")};
api->getFeedPostsPublic(U("my-tenant-123"), options).then([](pplx::task<std::shared_ptr<PublicFeedPostsResponse>> task){
    try{
        auto response = task.get();
        auto processed = std::make_shared<PublicFeedPostsResponse>(*response);
        // Χρησιμοποιήστε processed όπως απαιτείται
    }catch(const std::exception&){
        // Διαχειριστείτε το σφάλμα
    }
});

Στατιστικά δημοσιεύσεων ροής

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
postIds	vector<string	Yes
sso	string	No

Απάντηση

Επιστρέφει: FeedPostsStatsResponse

Παράδειγμα

Παράδειγμα getFeedPostsStats

Copy

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

Δημόσια λήψη αντιδράσεων χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
options	const GetUserReactsPublicOptions&	Yes

Απάντηση

Επιστρέφει: UserReactsResponse

Παράδειγμα

Παράδειγμα getUserReactsPublic

Copy

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

Δημόσια αντίδραση σε δημοσίευση ροής

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
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) {
    });

Ενημέρωση δημοσίευσης ροής

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
id	string	Yes
feedPost	FeedPost	Yes

Απόκριση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

Παράδειγμα updateFeedPost

Copy

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

Δημόσια ενημέρωση δημοσίευσης ροής

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
postId	string	Yes
updateFeedPostParams	UpdateFeedPostParams	Yes
options	const UpdateFeedPostPublicOptions&	Yes

Απάντηση

Επιστρέφει: CreateFeedPostResponse

Παράδειγμα

updateFeedPostPublic Παράδειγμα

Copy

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

Δημόσια σημείωση σχολίου

Parameters

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
commentId	string	Yes
isFlagged	bool	Yes
sso	string	No

Response

Επιστρέφει: APIEmptyResponse

Παράδειγμα

Παράδειγμα flagCommentPublic

Copy

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

Λήψη μεγάλου GIF

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
largeInternalURLSanitized	string	Yes

Απόκριση

Επιστρέφει: GifGetLargeResponse

Παράδειγμα

getGifLarge Παράδειγμα

Copy

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

Αναζήτηση GIF

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
search	string	Ναι
options	const GetGifsSearchOptions&	Ναι

Απόκριση

Επιστρέφει: GetGifsSearchResponse

Παράδειγμα

Παράδειγμα getGifsSearch

Copy

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

Δημοφιλή GIF

Παράμετροι

Name	Type	Required	Description
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;
    }
});

Προσθήκη ετικέτας

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
createHashTagBody	CreateHashTagBody	Yes

Απάντηση

Επιστρέφει: CreateHashTagResponse

Παράδειγμα

Παράδειγμα addHashTag

Copy

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

Μαζική προσθήκη ετικετών

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Ναι

Απόκριση

Επιστρέφει: BulkCreateHashTagsResponse

Παράδειγμα

addHashTagsBulk Παράδειγμα

Copy

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

Διαγραφή ετικέτας

Parameters

Όνομα	Τύπος	Απαιτείται
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) {
    });

Λήψη ετικετών

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
page	double	Όχι

Απόκριση

Επιστρέφει: GetHashTagsResponse

Παράδειγμα

getHashTags Παράδειγμα

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
boost::optional<double> page = 2.0;
api->getHashTags(tenantId, page).then([](pplx::task<std::shared_ptr<GetHashTagsResponse>> task) {
    try {
        auto resultPtr = task.get();
        auto response = std::make_shared<GetHashTagsResponse>(*resultPtr);
        // χρήση απόκρισης
    } catch (const std::exception&) {
        // διαχείριση σφάλματος
    }
});

Διόρθωση ετικέτας

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
tag	string	Ναι
updateHashTagBody	UpdateHashTagBody	Ναι

Απάντηση

Επιστρέφει: UpdateHashTagResponse

Παράδειγμα

Παράδειγμα patchHashTag

Copy

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

Διαγραφή ψήφου συντονισμού

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
commentId	string	Yes
voteId	string	Yes
options	const DeleteModerationVoteOptions&	Yes

Απάντηση

Επιστρέφει: VoteDeleteResponse

Παράδειγμα

Παράδειγμα deleteModerationVote

Copy

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

Λήψη σχολίων API

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
options	const GetApiCommentsOptions&	Ναι

Απάντηση

Επιστρέφει: ModerationAPIGetCommentsResponse

Παράδειγμα

getApiComments Παράδειγμα

Copy

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

Λήψη κατάστασης εξαγωγής API

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
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&){
        }
    });

Λήψη ID API

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
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&){
    }
});

Λήψη χρηστών με απαγόρευση από σχόλιο

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Απόκριση

Επιστρέφει: GetBannedUsersFromCommentResponse

Παράδειγμα

Παράδειγμα getBanUsersFromComment

Copy

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

Λήψη κατάστασης απαγόρευσης σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
commentId	string	Ναι
sso	string	Όχι

Απάντηση

Επιστρέφει: GetCommentBanStatusResponse

Παράδειγμα

Παράδειγμα getCommentBanStatus

Copy

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

Λήψη παιδιών σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
commentId	string	Ναι
sso	string	Όχι

Απάντηση

Επιστρέφει: ModerationAPIChildCommentsResponse

Παράδειγμα

getCommentChildren Παράδειγμα

Copy

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

Λήψη μετρήσεων

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
options	const GetCountOptions&	Ναι

Απάντηση

Επιστρέφει: ModerationAPICountCommentsResponse

Παράδειγμα

Παράδειγμα getCount

Copy

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

Λήψη μετρήσεων

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
sso	string	No

Απόκριση

Επιστρέφει: GetBannedUsersCountResponse

Παράδειγμα

Παράδειγμα getCounts

Copy

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

Λήψη αρχείων

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Απάντηση

Επιστρέφει: ModerationAPIGetLogsResponse

Παράδειγμα

Παράδειγμα getLogs

Copy

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

Λήψη χειροκίνητων σημάτων

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
sso	string	No

Απόκριση

Επιστρέφει: GetTenantManualBadgesResponse

Παράδειγμα

Παράδειγμα getManualBadges

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> sso = boost::make_optional(U("user@example.com"));
api->getManualBadges(tenantId, sso)
    .then([](pplx::task<std::shared_ptr<GetTenantManualBadgesResponse>> t) {
        try {
            auto response = t.get();
            // επεξεργασία απόκρισης, π.χ., response->badgeList
        } catch (const std::exception& ex) {
            // διαχείριση σφάλματος
        }
    });

Λήψη χειροκίνητων σημάτων για χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
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&){
    }
});

Λήψη σχολίου συντονισμού

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
commentId	string	Yes
options	const GetModerationCommentOptions&	Yes

Απόκριση

Επιστρέφει: ModerationAPICommentResponse

Παράδειγμα

Παράδειγμα getModerationComment

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-456");
GetModerationCommentOptions options;
options.includeDeleted = boost::optional<bool>(true);
options.locale = boost::optional<utility::string_t>(utility::conversions::to_string_t("en-US"));
api->getModerationComment(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<ModerationAPICommentResponse>> task) {
        try {
            auto response = task.get();
            // Επεξεργασία της απόκρισης όπως απαιτείται
        } catch (const std::exception& ex) {
            // Διαχείριση σφάλματος
        }
    });

Λήψη κειμένου σχολίου συντονισμού

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Απόκριση

Επιστρέφει: GetCommentTextResponse

Παράδειγμα

Παράδειγμα getModerationCommentText

Copy

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

Λήψη σύνοψης προ-απαγόρευσης

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
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();
            // επεξεργασία σύνοψης
        } catch (const std::exception&) {
            // διαχείριση σφάλματος
        }
    });

Λήψη σύνοψης αναζήτησης σχολίων

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
options	const GetSearchCommentsSummaryOptions&	Ναι

Απάντηση

Επιστρέφει: ModerationCommentSearchResponse

Παράδειγμα

Παράδειγμα getSearchCommentsSummary

Copy

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

Λήψη σελίδων αναζήτησης

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
options	const GetSearchPagesOptions&	Yes

Απόκριση

Returns: ModerationPageSearchResponse

Παράδειγμα

Παράδειγμα getSearchPages

Copy

GetSearchPagesOptions options;
options.pageNumber = boost::optional<int>(1);
options.pageSize = boost::optional<int>(50);
options.searchTerm = boost::optional<utility::string_t>(U("spam"));
api->getSearchPages(U("my-tenant-123"), options)
    .then([](pplx::task<std::shared_ptr<ModerationPageSearchResponse>> task) {
        try {
            auto response = task.get();
            // χρήση της απόκρισης
        } catch (const std::exception& e) {
            // διαχείριση σφάλματος
        }
    });

Λήψη ιστοτόπων αναζήτησης

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
options	const GetSearchSitesOptions&	Ναι

Απάντηση

Επιστρέφει: ModerationSiteSearchResponse

Παράδειγμα

Παράδειγμα getSearchSites

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
GetSearchSitesOptions options;
options.query = boost::make_optional(utility::string_t(U("example query")));
options.limit = boost::make_optional(25);
api->getSearchSites(tenantId, options)
   .then([](pplx::task<std::shared_ptr<ModerationSiteSearchResponse>> t) {
       try {
           auto response = t.get();
           auto respPtr = std::make_shared<ModerationSiteSearchResponse>(*response);
           for (const auto& site : respPtr->sites) {
               // λογική επεξεργασίας
           }
       } catch (const std::exception&) {
           // διαχείριση σφάλματος
       }
   });

Λήψη προτάσεων αναζήτησης

Parameters

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
options	const GetSearchSuggestOptions&	Yes

Απάντηση

Επιστρέφει: ModerationSuggestResponse

Παράδειγμα

Παράδειγμα getSearchSuggest

Copy

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

Λήψη χρηστών αναζήτησης

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
options	const GetSearchUsersOptions&	Ναι

Απόκριση

Επιστρέφει: ModerationUserSearchResponse

Παράδειγμα

getSearchUsers Παράδειγμα

Copy

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

Λήψη παράγοντα εμπιστοσύνης

Parameters

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
options	const GetTrustFactorOptions&	Ναι

Response

Επιστρέφει: GetUserTrustFactorResponse

Example

Παράδειγμα getTrustFactor

Copy

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

Λήψη προτίμησης απαγόρευσης χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
sso	string	Όχι

Απάντηση

Επιστρέφει: APIModerateGetUserBanPreferencesResponse

Παράδειγμα

Παράδειγμα getUserBanPreference

Copy

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

Λήψη εσωτερικού προφίλ χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
options	const GetUserInternalProfileOptions&	Yes

Απάντηση

Επιστρέφει: GetUserInternalProfileResponse

Παράδειγμα

getUserInternalProfile Παράδειγμα

Copy

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

Αναπροσαρμογή ψήφων σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
commentId	string	Yes
adjustCommentVotesParams	AdjustCommentVotesParams	Yes
options	const PostAdjustCommentVotesOptions&	Yes

Απάντηση

Επιστρέφει: AdjustVotesResponse

Παράδειγμα

postAdjustCommentVotes Παράδειγμα

Copy

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

Εξαγωγή API

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
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();

Απαγόρευση χρήστη από σχόλιο

Parameters

Name	Type	Required
tenantId	string	Ναι
commentId	string	Ναι
options	const PostBanUserFromCommentOptions&	Ναι

Response

Returns: BanUserFromCommentResult

Example

postBanUserFromComment Παράδειγμα

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("comment-456789");
PostBanUserFromCommentOptions options;
options.reason = boost::optional<utility::string_t>(U("spam"));
options.durationDays = boost::optional<int>(30);
api->postBanUserFromComment(tenantId, commentId, options)
    .then([](std::shared_ptr<BanUserFromCommentResult> result) {
        // διαχείριση αποτελέσματος
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* διαχείριση σφάλματος */ }
    });

Αναίρεση απαγόρευσης χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
banUserUndoParams	BanUserUndoParams	Yes
sso	string	No

Απάντηση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

postBanUserUndo Παράδειγμα

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
BanUserUndoParams banParams;
banParams.userId = utility::string_t(U("user-567"));
banParams.reason = utility::string_t(U("reinstated"));
boost::optional<utility::string_t> sso = utility::string_t(U("sso-token-abc"));
api->postBanUserUndo(tenantId, banParams, sso).then([](std::shared_ptr<APIEmptyResponse> resp){
    // διαχείριση επιτυχίας
});

Μαζική σύνοψη προ-απαγόρευσης

Παράμετροι

Όνομα	Τύπος	Απαιτείται
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;
    });

Σχόλια κατά ID

Παράμετροι

Όνομα	Τύπος	Απαιτείται
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&){ }
});

Σημείωση σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
commentId	string	Yes
options	const PostFlagCommentOptions&	Yes

Απάντηση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

Παράδειγμα postFlagComment

Copy

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

Αφαίρεση σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
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) {
            // Διαχείριση σφάλματος
        }
    });

Αποκατάσταση διαγραμμένου σχολίου

Παράμετρα

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
commentId	string	Yes
options	const PostRestoreDeletedCommentOptions&	Yes

Απάντηση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

postRestoreDeletedComment Παράδειγμα

Copy

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

Ορισμός κατάστασης έγκρισης σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
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) {
        }
    });

Ορισμός κατάστασης ελέγχου σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
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){
        }
    });

Ορισμός κατάστασης spam σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
commentId	string	Ναι
options	const PostSetCommentSpamStatusOptions&	Ναι

Απάντηση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

postSetCommentSpamStatus Παράδειγμα

Copy

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

Ορισμός κειμένου σχολίου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
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&) {}
    });

Αναίρεση σημείωσης σχολίου

Parameters

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
commentId	string	Yes
options	const PostUnFlagCommentOptions&	Yes

Response

Επιστρέφει: APIEmptyResponse

Example

Παράδειγμα 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&) {}
    });

Ψήφος

Parameters

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
commentId	string	Ναι
options	const PostVoteOptions&	Ναι

Response

Επιστρέφει: VoteResponse

Παράδειγμα

postVote Παράδειγμα

Copy

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

Απόδοση σήματος

Παράμετροι

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

Απάντηση

Επιστρέφει: AwardUserBadgeResponse

Παράδειγμα

Παράδειγμα putAwardBadge

Copy

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

Κλείσιμο νήματος

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
urlId	string	Ναι
sso	string	Όχι

Απάντηση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

Παράδειγμα putCloseThread

Copy

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

Αφαίρεση σήματος

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
badgeId	string	Yes
options	const PutRemoveBadgeOptions&	Yes

Απόκριση

Επιστρέφει: RemoveUserBadgeResponse

Παράδειγμα

Παράδειγμα putRemoveBadge

Copy

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

Άνοιγμα ξανά νήματος

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
urlId	string	Ναι
sso	string	Όχι

Απόκριση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

Παράδειγμα putReopenThread

Copy

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

Ορισμός παράγοντα εμπιστοσύνης

Parameters

Όνομα	Τύπος	Υποχρεωτικό	Περιγραφή
tenantId	string	Ναι
options	const SetTrustFactorOptions&	Ναι

Response

Επιστρέφει: SetUserTrustFactorResponse

Example

Παράδειγμα setTrustFactor

Copy

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

Δημιουργία συντονιστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
createModeratorBody	CreateModeratorBody	Yes

Απόκριση

Επιστρέφει: CreateModeratorResponse

Παράδειγμα

createModerator Παράδειγμα

Copy

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

Διαγραφή συντονιστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
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) {
        // χειρισμός επιτυχίας
    });

Λήψη συντονιστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
id	string	Ναι

Απάντηση

Επιστρέφει: GetModeratorResponse

Παράδειγμα

Παράδειγμα getModerator

Copy

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

Λήψη συντονιστών

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
skip	double	Όχι

Απόκριση

Επιστρέφει: GetModeratorsResponse

Παράδειγμα

Παράδειγμα getModerators

Copy

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

Αποστολή πρόσκλησης

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
id	string	Ναι
fromName	string	Ναι

Απάντηση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

Παράδειγμα sendInvite

Copy

boost::optional<utility::string_t> cc = utility::conversions::to_string_t("cc@example.com");
api->sendInvite(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("invitee@example.com"),
    utility::conversions::to_string_t("John Doe")
).then([](std::shared_ptr<APIEmptyResponse> resp) {
    // διαχειριστείτε την επιτυχημένη πρόσκληση
});

Ενημέρωση συντονιστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
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&) {} });

Διαγραφή αριθμού ειδοποιήσεων

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
id	string	Yes

Απάντηση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

deleteNotificationCount Παράδειγμα

Copy

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

Λήψη αποθηκευμένου αριθμού ειδοποιήσεων

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
id	string	Yes

Απάντηση

Επιστρέφει: GetCachedNotificationCountResponse

Παράδειγμα

getCachedNotificationCount Παράδειγμα

Copy

auto tenantId = boost::optional<utility::string_t>(utility::conversions::to_string_t("my-tenant-123"));
auto userId = boost::optional<utility::string_t>(utility::conversions::to_string_t("user-456"));
api->getCachedNotificationCount(tenantId.value(), userId.value())
    .then([](pplx::task<std::shared_ptr<GetCachedNotificationCountResponse>> task) {
        try {
            auto response = task.get();
            // επεξεργασία της απόκρισης
        } catch (const std::exception&) {
            // διαχείριση σφάλματος
        }
    });

Λήψη αριθμού ειδοποιήσεων

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
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) {
        }
    });

Λήψη ειδοποιήσεων

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
options	const GetNotificationsOptions&	Yes

Απάντηση

Επιστρέφει: GetNotificationsResponse

Παράδειγμα

getNotifications Παράδειγμα

Copy

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

Ενημέρωση ειδοποίησης

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
id	string	Ναι
updateNotificationBody	UpdateNotificationBody	Ναι
userId	string	Όχι

Απάντηση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

Παράδειγμα updateNotification

Copy

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

Δημιουργία αντίδρασης σε σελίδα V1

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
urlId	string	Yes
title	string	No

Απάντηση

Επιστρέφει: CreateV1PageReact

Παράδειγμα

createV1PageReact Παράδειγμα

Copy

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

Δημιουργία αντίδρασης σε σελίδα V2

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
urlId	string	Ναι
id	string	Ναι
title	string	Όχι

Απόκριση

Επιστρέφει: CreateV1PageReact

Παράδειγμα

createV2PageReact Παράδειγμα

Copy

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

Διαγραφή αντίδρασης σε σελίδα V1

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
urlId	string	Yes

Απόκριση

Επιστρέφει: CreateV1PageReact

Παράδειγμα

Παράδειγμα deleteV1PageReact

Copy

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

Διαγραφή αντίδρασης σε σελίδα V2

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
urlId	string	Yes
id	string	Yes

Απόκριση

Επιστρέφει: CreateV1PageReact

Παράδειγμα

Παράδειγμα deleteV2PageReact

Copy

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

Λήψη likes σελίδας V1

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
urlId	string	Ναι

Απόκριση

Επιστρέφει: GetV1PageLikes

Παράδειγμα

Παράδειγμα getV1PageLikes

Copy

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

Λήψη αντιδράσεων σελίδας V2

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
urlId	string	Yes

Απόκριση

Επιστρέφει: GetV2PageReacts

Παράδειγμα

getV2PageReacts Παράδειγμα

Copy

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

Λήψη χρηστών αντιδράσεων σελίδας V2

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
urlId	string	Yes
id	string	Yes

Απόκριση

Επιστρέφει: GetV2PageReactUsersResponse

Παράδειγμα

Παράδειγμα getV2PageReactUsers

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto urlId = utility::conversions::to_string_t("page-456");
auto id = utility::conversions::to_string_t("react-789");
boost::optional<utility::string_t> maybeFilter;
api->getV2PageReactUsers(tenantId, urlId, id).then([](pplx::task<std::shared_ptr<GetV2PageReactUsersResponse>> task){
    try{
        auto response = task.get();
        // Χρησιμοποιήστε την απόκριση όπως χρειάζεται
    }catch(const std::exception&){
        // Διαχειριστείτε το σφάλμα
    }
});

Προσθήκη σελίδας

Parameters

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
createAPIPageData	CreateAPIPageData	Ναι

Response

Returns: AddPageAPIResponse

Example

Παράδειγμα addPage

Copy

auto createData = CreateAPIPageData{};
createData.title = utility::string_t(U("Welcome Page"));
createData.url = utility::string_t(U("https://example.com/welcome"));
createData.description = boost::optional<utility::string_t>(utility::string_t(U("Landing page for new users")));
api->addPage(utility::string_t(U("my-tenant-123")), createData)
    .then([](std::shared_ptr<AddPageAPIResponse> response) {
        if (response && response->success) {
            // διαχειριστείτε την επιτυχή προσθήκη
        } else {
            // διαχειριστείτε το σφάλμα
        }
    });

Διαγραφή σελίδας

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
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();
           // process response as needed
       } catch (const std::exception& ex) {
           // handle error
       }
   });

Λήψη χρηστών εκτός σύνδεσης

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.

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
urlId	string	Yes
options	const GetOfflineUsersOptions&	Yes

Απάντηση

Επιστρέφει: PageUsersOfflineResponse

Παράδειγμα

getOfflineUsers Παράδειγμα

Copy

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

Λήψη χρηστών 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).

Parameters

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
urlId	string	Yes
options	const GetOnlineUsersOptions&	Yes

Response

Επιστρέφει: PageUsersOnlineResponse

Example

getOnlineUsers Παράδειγμα

Copy

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

Λήψη σελίδας με URL ID

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
urlId	string	Ναι

Απάντηση

Επιστρέφει: GetPageByURLIdAPIResponse

Παράδειγμα

Παράδειγμα getPageByURLId

Copy

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

Λήψη σελίδων

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι

Απάντηση

Επιστρέφει: GetPagesAPIResponse

Παράδειγμα

Παράδειγμα getPages

Copy

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

Δημόσια λήψη σελίδων

List pages for a tenant. Used by the FChat desktop client to populate its room list.
Απαιτεί το enableFChat να είναι true στη διαμορφωμένη προσαρμοσμένη ρύθμιση για κάθε σελίδα.
Οι σελίδες που απαιτούν SSO φιλτράρονται με βάση την πρόσβαση ομάδας του χρήστη που κάνει το αίτημα.

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
options	const GetPagesPublicOptions&	Yes

Απάντηση

Επιστρέφει: 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&){
        // διαχείριση σφάλματος αν χρειάζεται
    }
});

Λήψη πληροφοριών χρηστών

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

Μαζική πληροφορία χρηστών για έναν ενοικιαστή. Δεδομένων των userIds, επιστρέφει πληροφορίες εμφάνισης από User / SSOUser.
Χρησιμοποιείται από το widget σχολίων για να εμπλουτίσει χρήστες που μόλις εμφανίστηκαν μέσω ενός γεγονότος παρουσίας.
Χωρίς πλαίσιο σελίδας: η ιδιωτικότητα εφαρμόζεται ομοιόμορφα (τα ιδιωτικά προφίλ είναι καλυμμένα).

Parameters

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
ids	string	Yes

Response

Returns: PageUsersInfoResponse

Example

Παράδειγμα getUsersInfo

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t ids = U("alice@example.com,bob@example.com");
boost::optional<utility::string_t> locale = boost::make_optional(U("en-US"));
api->getUsersInfo(tenantId, ids).then([](pplx::task<std::shared_ptr<PageUsersInfoResponse>> t){
    try{
        auto response = t.get();
        // επεξεργασία απάντησης
    }catch(const std::exception&){
        // χειρισμός σφάλματος
    }
});

Διόρθωση σελίδας

Parameters

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
id	string	Yes
updateAPIPageData	UpdateAPIPageData	Yes

Response

Επιστρέφει: PatchPageAPIResponse

Example

patchPage Παράδειγμα

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t pageId = U("page-789");
UpdateAPIPageData update;
update.title = boost::optional<utility::string_t>(U("Updated Page Title"));
update.metadata = boost::optional<utility::string_t>(U("{\"author\":\"jane.doe@example.com\"}"));
api->patchPage(tenantId, pageId, update)
    .then([](std::shared_ptr<PatchPageAPIResponse> response) {
        if (response && response->isSuccess) {
            // διαχείριση επιτυχίας
        }
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

Διαγραφή εκκρεμούς webhook συμβάν

Parameters

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
id	string	Yes

Response

Επιστρέφει: APIEmptyResponse

Example

deletePendingWebhookEvent Παράδειγμα

Copy

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

Λήψη αριθμού εκκρεμών webhook συμβάντων

Παράμετροι

Name	Type	Required	Description
tenantId	string	Ναι
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();
    });

Λήψη εκκρεμών webhook συμβάντων

Παράμετροι

Name	Type	Required	Description
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&) {}
    });

Δημιουργία ρύθμισης ερώτησης

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
createQuestionConfigBody	CreateQuestionConfigBody	Yes

Απάντηση

Επιστρέφει: CreateQuestionConfigResponse

Παράδειγμα

createQuestionConfig Παράδειγμα

Copy

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

Διαγραφή ρύθμισης ερώτησης

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
id	string	Yes

Απόκριση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

deleteQuestionConfig Παράδειγμα

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto configId = utility::conversions::to_string_t("question-config-456");
api->deleteQuestionConfig(tenantId, configId)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // χειρισμός επιτυχούς διαγραφής
    })
    .then([](pplx::task<void> t) {
        try {
            t.get();
        } catch (const std::exception&) {
            // χειρισμός σφάλματος
        }
    });

Λήψη ρύθμισης ερώτησης

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
id	string	Yes

Απάντηση

Returns: GetQuestionConfigResponse

Παράδειγμα

Παράδειγμα getQuestionConfig

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto questionId = utility::conversions::to_string_t("question-456");
api->getQuestionConfig(tenantId, questionId)
    .then([](pplx::task<std::shared_ptr<GetQuestionConfigResponse>> task) {
        try {
            auto response = task.get();
            // Χρησιμοποιήστε την απάντηση όπως χρειάζεται
        } catch (const std::exception&) {
            // Διαχείριση σφάλματος
        }
    });

Λήψη ρυθμίσεων ερώτησης

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
skip	double	Όχι

Απάντηση

Επιστρέφει: GetQuestionConfigsResponse

Παράδειγμα

Παράδειγμα getQuestionConfigs

Copy

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

Ενημέρωση ρύθμισης ερώτησης

Παράμετρα

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
id	string	Yes
updateQuestionConfigBody	UpdateQuestionConfigBody	Yes

Απάντηση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

updateQuestionConfig Παράδειγμα

Copy

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

Δημιουργία αποτελέσματος ερώτησης

Παράμετροι

Name	Type	Required	Description
tenantId	string	Yes
createQuestionResultBody	CreateQuestionResultBody	Yes

Απόκριση

Επιστρέφει: CreateQuestionResultResponse

Παράδειγμα

createQuestionResult Παράδειγμα

Copy

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

Διαγραφή αποτελέσματος ερώτησης

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
id	string	Yes

Απόκριση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

Παράδειγμα deleteQuestionResult

Copy

boost::optional<utility::string_t> optTenant = utility::conversions::to_string_t( "my-tenant-123" );
utility::string_t questionId = utility::conversions::to_string_t( "question-456" );
if ( optTenant )
{
    api->deleteQuestionResult( *optTenant, questionId )
        .then( []( pplx::task<std::shared_ptr<APIEmptyResponse>> t )
        {
            try
            {
                auto resp = t.get();
                // επεξεργασία επιτυχίας
            }
            catch ( const std::exception& e )
            {
                // επεξεργασία σφάλματος
            }
        } );
}

Λήψη αποτελέσματος ερώτησης

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
id	string	Yes

Απόκριση

Επιστρέφει: GetQuestionResultResponse

Παράδειγμα

Παράδειγμα getQuestionResult

Copy

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

Λήψη αποτελεσμάτων ερώτησης

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
options	const GetQuestionResultsOptions&	Ναι

Απόκριση

Επιστρέφει: GetQuestionResultsResponse

Παράδειγμα

Παράδειγμα getQuestionResults

Copy

utility::string_t tenantId = U("my-tenant-123");
GetQuestionResultsOptions options;
options.questionId = boost::optional<utility::string_t>(U("question-456"));
options.includeDeleted = boost::optional<bool>(false);
api->getQuestionResults(tenantId, options)
    .then([](pplx::task<std::shared_ptr<GetQuestionResultsResponse>> t) {
        auto response = t.get();
        // διαχείριση απόκρισης
    });

Ενημέρωση αποτελέσματος ερώτησης

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
id	string	Ναι
updateQuestionResultBody	UpdateQuestionResultBody	Ναι

Απόκριση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

Παράδειγμα updateQuestionResult

Copy

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

Σύνοψη αποτελεσμάτων ερώτησης

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
options	const AggregateQuestionResultsOptions&	Ναι

Απάντηση

Επιστρέφει: AggregateQuestionResultsResponse

Παράδειγμα

Παράδειγμα aggregateQuestionResults

Copy

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

Μαζική σύνοψη αποτελεσμάτων ερώτησης

Parameters

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Yes
forceRecalculate	bool	No

Response

Επιστρέφει: BulkAggregateQuestionResultsResponse

Παράδειγμα

Παράδειγμα bulkAggregateQuestionResults

Copy

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

Συνδυασμός σχολίων με αποτελέσματα ερώτησης

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
options	const CombineCommentsWithQuestionResultsOptions&	Yes

Απόκριση

Επιστρέφει: CombineQuestionResultsWithCommentsResponse

Παράδειγμα

combineCommentsWithQuestionResults Παράδειγμα

Copy

utility::string_t tenantId = utility::string_t("my-tenant-123");
CombineCommentsWithQuestionResultsOptions options;
options.questionId = utility::string_t("question-789");
options.maxComments = boost::optional<int>(50);
api->combineCommentsWithQuestionResults(tenantId, options).then(
    [](pplx::task<std::shared_ptr<CombineQuestionResultsWithCommentsResponse>> task){
        try{
            auto respPtr = task.get();
            auto combined = std::make_shared<CombineQuestionResultsWithCommentsResponse>(*respPtr);
            // Χρησιμοποιήστε το combined όπως απαιτείται
        }catch(const std::exception&){
        }
    });

Προσθήκη χρήστη SSO

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
createAPISSOUserData	CreateAPISSOUserData	Yes

Απόκριση

Επιστρέφει: AddSSOUserAPIResponse

Παράδειγμα

Παράδειγμα addSSOUser

Copy

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

Διαγραφή χρήστη SSO

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
id	string	Ναι
options	const DeleteSSOUserOptions&	Ναι

Απόκριση

Επιστρέφει: DeleteSSOUserAPIResponse

Παράδειγμα

deleteSSOUser Παράδειγμα

Copy

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

Λήψη χρήστη SSO με email

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
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&) {
    }
});

Λήψη χρήστη SSO με ID

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
id	string	Yes

Απόκριση

Επιστρέφει: GetSSOUserByIdAPIResponse

Παράδειγμα

Παράδειγμα getSSOUserById

Copy

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

Λήψη χρηστών SSO

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
skip	int32_t	No

Απόκριση

Επιστρέφει: GetSSOUsersResponse

Παράδειγμα

Παράδειγμα getSSOUsers

Copy

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

Διόρθωση χρήστη SSO

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
id	string	Yes
updateAPISSOUserData	UpdateAPISSOUserData	Yes
updateComments	bool	No

Απόκριση

Επιστρέφει: PatchSSOUserAPIResponse

Παράδειγμα

patchSSOUser Παράδειγμα

Copy

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

Αντικατάσταση χρήστη SSO

Parameters

Όνομα	Τύπος	Απαιτείται
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();
});

Δημιουργία συνδρομής

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Yes

Απάντηση

Επιστρέφει: CreateSubscriptionAPIResponse

Παράδειγμα

createSubscription Παράδειγμα

Copy

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

Διαγραφή συνδρομής

Παράμετροι

Name	Type	Required
tenantId	string	Yes
id	string	Yes
userId	string	No

Απόκριση

Επιστρέφει: DeleteSubscriptionAPIResponse

Παράδειγμα

Παράδειγμα deleteSubscription

Copy

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

Λήψη συνδρομών

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
userId	string	Όχι

Απάντηση

Επιστρέφει: 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) {
            // διαχείριση σφάλματος
        }
    }
);

Ενημέρωση συνδρομής

Παράμετρα

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	Yes
userId	string	No

Απάντηση

Επιστρέφει: UpdateSubscriptionAPIResponse

Παράδειγμα

Παράδειγμα updateSubscription

Copy

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

Λήψη καθημερινών χρήσεων ενοικιαστή

Parameters

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
options	const GetTenantDailyUsagesOptions&	Yes

Response

Επιστρέφει: GetTenantDailyUsagesResponse

Example

Παράδειγμα 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();

Δημιουργία πακέτου ενοικιαστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
createTenantPackageBody	CreateTenantPackageBody	Yes

Απόκριση

Επιστρέφει: CreateTenantPackageResponse

Παράδειγμα

Παράδειγμα createTenantPackage

Copy

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

Διαγραφή πακέτου ενοικιαστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
id	string	Yes

Απόκριση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

deleteTenantPackage Παράδειγμα

Copy

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

Λήψη πακέτου ενοικιαστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
id	string	Ναι

Απάντηση

Επιστρέφει: GetTenantPackageResponse

Παράδειγμα

getTenantPackage Παράδειγμα

Copy

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

Λήψη πακέτων ενοικιαστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
skip	double	No

Απόκριση

Επιστρέφει: GetTenantPackagesResponse

Παράδειγμα

Παράδειγμα getTenantPackages

Copy

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

Αντικατάσταση πακέτου ενοικιαστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
id	string	Yes
replaceTenantPackageBody	ReplaceTenantPackageBody	Yes

Απάντηση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

replaceTenantPackage Παράδειγμα

Copy

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

Ενημέρωση πακέτου ενοικιαστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
id	string	Ναι
updateTenantPackageBody	UpdateTenantPackageBody	Ναι

Απάντηση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

updateTenantPackage Παράδειγμα

Copy

auto body = std::make_shared<UpdateTenantPackageBody>();
body->packageId = utility::conversions::to_string_t("premium-plan");
body->expirationDate = utility::conversions::to_string_t("2025-12-31");
body->notes = boost::optional<utility::string_t>(utility::conversions::to_string_t("Upgraded package"));
api->updateTenantPackage(utility::conversions::to_string_t("my-tenant-123"),
                         utility::conversions::to_string_t("pkg-456"),
                         body)
    .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> task) {
        try {
            auto response = task.get();
            // success handling
        } catch (const std::exception& ex) {
            // error handling
        }
    });

Δημιουργία χρήστη ενοικιαστή

Parameters

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
createTenantUserBody	CreateTenantUserBody	Yes

Response

Επιστρέφει: CreateTenantUserResponse

Παράδειγμα

createTenantUser Παράδειγμα

Copy

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

Διαγραφή χρήστη ενοικιαστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
id	string	Ναι
options	const DeleteTenantUserOptions&	Ναι

Απάντηση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

deleteTenantUser Παράδειγμα

Copy

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

Λήψη χρήστη ενοικιαστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
id	string	Yes

Απάντηση

Επιστρέφει: GetTenantUserResponse

Παράδειγμα

Παράδειγμα getTenantUser

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user@example.com");
api->getTenantUser(tenantId, userId)
    .then([](pplx::task<std::shared_ptr<GetTenantUserResponse>> task) {
        try {
            auto response = task.get();
            // Χρησιμοποιήστε την απόκριση όπως απαιτείται
        } catch (const std::exception&) {
            // Διαχείριση σφάλματος
        }
    });

Λήψη χρηστών ενοικιαστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
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&) {
    }
});

Αντικατάσταση χρήστη ενοικιαστή

Parameters

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
id	string	Yes
replaceTenantUserBody	ReplaceTenantUserBody	Yes
updateComments	string	No

Response

Επιστρέφει: 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){ });

Αποστολή συνδέσμου σύνδεσης

Παράμετροι

Name	Type	Required
tenantId	string	Yes
id	string	Yes
redirectURL	string	No

Απόκριση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

Παράδειγμα sendLoginLink

Copy

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

Ενημέρωση χρήστη ενοικιαστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
id	string	Ναι
updateTenantUserBody	UpdateTenantUserBody	Ναι
updateComments	string	Όχι

Απάντηση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

updateTenantUser Παράδειγμα

Copy

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

Δημιουργία ενοικιαστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
createTenantBody	CreateTenantBody	Yes

Απόκριση

Επιστρέφει: CreateTenantResponse

Παράδειγμα

createTenant Παράδειγμα

Copy

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

Διαγραφή ενοικιαστή

Παράμετροι

Name	Type	Required
tenantId	string	Yes
id	string	Yes
sure	string	No

Απόκριση

Returns: APIEmptyResponse

Παράδειγμα

Παράδειγμα deleteTenant

Copy

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

Λήψη ενοικιαστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
id	string	Yes

Απάντηση

Επιστρέφει: GetTenantResponse

Παράδειγμα

Παράδειγμα getTenant

Copy

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

Λήψη ενοικιαστών

Παράμετροι

Όνομα	Τύπος	Υποχρεωτικό	Περιγραφή
tenantId	string	Ναι
options	const GetTenantsOptions&	Ναι

Απόκριση

Επιστρέφει: GetTenantsResponse

Παράδειγμα

getTenants Παράδειγμα

Copy

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

Ενημέρωση ενοικιαστή

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
id	string	Yes
updateTenantBody	UpdateTenantBody	Yes

Απάντηση

Επιστρέφει: APIEmptyResponse

Παράδειγμα

Παράδειγμα updateTenant

Copy

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

Αλλαγή κατάστασης αιτήματος

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
userId	string	Ναι
id	string	Ναι
changeTicketStateBody	ChangeTicketStateBody	Ναι

Απόκριση

Επιστρέφει: ChangeTicketStateResponse

Παράδειγμα

Παράδειγμα changeTicketState

Copy

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

Δημιουργία αιτήματος

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
userId	string	Ναι
createTicketBody	CreateTicketBody	Ναι

Απάντηση

Επιστρέφει: CreateTicketResponse

Παράδειγμα

Παράδειγμα createTicket

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("john.doe@example.com");
CreateTicketBody ticketBody;
ticketBody.setSubject(utility::conversions::to_string_t("Login Issue"));
ticketBody.setDescription(utility::conversions::to_string_t("Cannot log in after password reset."));
boost::optional<int> priority = 2;
ticketBody.setPriority(priority);
api->createTicket(tenantId, userId, ticketBody).then([](pplx::task<std::shared_ptr<CreateTicketResponse>> task){
    try{
        auto response = task.get();
        // Χρησιμοποιήστε την απάντηση όπως χρειάζεται
    }catch(const std::exception&){
        // Διαχειριστείτε το σφάλμα
    }
});

Λήψη αιτήματος

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
id	string	Yes
userId	string	No

Απάντηση

Επιστρέφει: GetTicketResponse

Παράδειγμα

Παράδειγμα getTicket

Copy

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

Λήψη αιτημάτων

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
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&) {
    }
});

Λήψη μεταφράσεων

Παράμετροι

Όνομα	Τύπος	Απαιτείται
r_namespace	string	Ναι
component	string	Ναι
options	const GetTranslationsOptions&	Ναι

Απάντηση

Επιστρέφει: GetTranslationsResponse

Παράδειγμα

Παράδειγμα getTranslations

Copy

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

Ανέβασμα εικόνας

Ανέβασμα και αλλαγή μεγέθους εικόνας

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
file	HttpContent	Yes
options	const UploadImageOptions&	Yes

Απόκριση

Επιστρέφει: UploadImageResponse

Παράδειγμα

uploadImage Παράδειγμα

Copy

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

Λήψη προόδου σήματος χρήστη κατά ID

Parameters

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
id	string	Yes

Response

Επιστρέφει: APIGetUserBadgeProgressResponse

Παράδειγμα

Παράδειγμα getUserBadgeProgressById

Copy

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

Λήψη προόδου σήματος χρήστη κατά ID χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
userId	string	Ναι

Απάντηση

Επιστρέφει: APIGetUserBadgeProgressResponse

Παράδειγμα

Παράδειγμα getUserBadgeProgressByUserId

Copy

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

Λίστα προόδου σημάτων χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
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) {
            // επεξεργασία μπέιτζ
        }
    });

Δημιουργία σήματος χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
createUserBadgeParams	CreateUserBadgeParams	Yes

Απάντηση

Επιστρέφει: APICreateUserBadgeResponse

Παράδειγμα

Παράδειγμα createUserBadge

Copy

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

Διαγραφή σήματος χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
id	string	Yes

Απόκριση

Επιστρέφει: APIEmptySuccessResponse

Παράδειγμα

Παράδειγμα deleteUserBadge

Copy

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

Λήψη σήματος χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
id	string	Ναι

Απάντηση

Επιστρέφει: APIGetUserBadgeResponse

Παράδειγμα

Παράδειγμα getUserBadge

Copy

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

Λήψη σημάτων χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Ναι
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&) {
       }
   });

Ενημέρωση σήματος χρήστη

Παράμετροι

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateUserBadgeParams	UpdateUserBadgeParams	Yes

Απάντηση

Επιστρέφει: APIEmptySuccessResponse

Παράδειγμα

Παράδειγμα updateUserBadge

Copy

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

Λήψη αριθμού ειδοποιήσεων χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
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&){
        // διαχειριστείτε το σφάλμα
    }
});

Λήψη ειδοποιήσεων χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
options	const GetUserNotificationsOptions&	Yes

Απόκριση

Επιστρέφει: GetMyNotificationsResponse

Παράδειγμα

Παράδειγμα getUserNotifications

Copy

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

Επαναφορά αριθμού ειδοποιήσεων χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
sso	string	No

Απόκριση

Επιστρέφει: 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){
});

Επαναφορά ειδοποιήσεων χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
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) {
        // Επεξεργασία της απάντησης
    });

Ενημέρωση κατάστασης συνδρομής ειδοποιήσεων σχολίου χρήστη

Enable or disable notifications for a specific comment.

Parameters

Όνομα	Τύπος	Υποχρεωτικό
tenantId	string	Ναι
notificationId	string	Ναι
optedInOrOut	string	Ναι
commentId	string	Ναι
sso	string	Όχι

Response

Επιστρέφει: UpdateUserNotificationCommentSubscriptionStatusResponse

Example

updateUserNotificationCommentSubscriptionStatus Παράδειγμα

Copy

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

Ενημέρωση κατάστασης συνδρομής ειδοποιήσεων σελίδας χρήστη

Enable or disable notifications for a page. When users are subscribed to a page, notifications are created for new root comments, and also

Parameters

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
urlId	string	Yes
url	string	Yes
pageTitle	string	Yes
subscribedOrUnsubscribed	string	Yes
sso	string	No

Response

Επιστρέφει: UpdateUserNotificationPageSubscriptionStatusResponse

Example

Παράδειγμα updateUserNotificationPageSubscriptionStatus

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("page-456");
utility::string_t url = U("https://example.com/articles/awesome-article");
utility::string_t pageTitle = U("Awesome Article");
utility::string_t subscription = U("subscribed");
boost::optional<utility::string_t> sso = boost::make_optional<utility::string_t>(U("sso-token-789"));
api->updateUserNotificationPageSubscriptionStatus(tenantId, urlId, url, pageTitle, subscription, sso)
    .then([](std::shared_ptr<UpdateUserNotificationPageSubscriptionStatusResponse> resp) {
        // process resp if needed
    });

Ενημέρωση κατάστασης ειδοποιήσεων χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
notificationId	string	Ναι
newStatus	string	Ναι
sso	string	Όχι

Απόκριση

Επιστρέφει: UpdateUserNotificationStatusResponse

Παράδειγμα

Παράδειγμα updateUserNotificationStatus

Copy

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

Λήψη καταστάσεων παρουσίας χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Yes
urlIdWS	string	Yes
userIds	string	Yes

Απάντηση

Επιστρέφει: GetUserPresenceStatusesResponse

Παράδειγμα

Παράδειγμα getUserPresenceStatuses

Copy

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

Αναζήτηση χρηστών

Παράμετροι

Όνομα	Τύπος	Απαιτείται
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&){}
});

Λήψη χρήστη

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
id	string	Yes

Απάντηση

Επιστρέφει: GetUserResponse

Παράδειγμα

Παράδειγμα getUser

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user-789");
boost::optional<utility::string_t> optTag = boost::none;
api->getUser(tenantId, userId)
    .then([=](pplx::task<std::shared_ptr<GetUserResponse>> task) {
        try {
            auto response = task.get();
            if (!response) {
                response = std::make_shared<GetUserResponse>();
            }
            // επεξεργασία της απάντησης όπως απαιτείται
        } catch (const std::exception&) {
            // διαχείριση σφάλματος
        }
    });

Δημιουργία ψήφου

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
commentId	string	Ναι
direction	string	Ναι
options	const CreateVoteOptions&	Ναι

Απόκριση

Επιστρέφει: VoteResponse

Παράδειγμα

Παράδειγμα createVote

Copy

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

Διαγραφή ψήφου

Παράμετροι

Name	Type	Required
tenantId	string	Yes
id	string	Yes
editKey	string	No

Απάντηση

Επιστρέφει: VoteDeleteResponse

Παράδειγμα

Παράδειγμα deleteVote

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto voteId = utility::conversions::to_string_t("vote-9876");
boost::optional<utility::string_t> editKey = utility::conversions::to_string_t("edit-abc123");
api->deleteVote(tenantId, voteId, editKey).then([](pplx::task<std::shared_ptr<VoteDeleteResponse>> task) {
    try {
        auto response = task.get();
        // Process response as needed
    } catch (const std::exception&) {
        // Handle error
    }
});

Λήψη ψήφων

Παράμετροι

Όνομα	Τύπος	Απαιτείται	Περιγραφή
tenantId	string	Yes
urlId	string	Yes

Απάντηση

Επιστρέφει: GetVotesResponse

Παράδειγμα

getVotes Παράδειγμα

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto urlId = utility::string_t(U("article-456"));
boost::optional<utility::string_t> extraHeader = boost::none;
api->getVotes(tenantId, urlId).then([=](pplx::task<std::shared_ptr<GetVotesResponse>> task) {
    try {
        auto original = task.get();
        auto response = std::make_shared<GetVotesResponse>(*original);
    } catch (...) {
        // διαχείριση σφάλματος
    }
});

Λήψη ψήφων για χρήστη

Parameters

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

Response

Επιστρέφει: GetVotesForUserResponse

Example

Παράδειγμα 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

Χρήση

Σύνολο

Αρχεία ελέγχου

Αυθεντικοποίηση

Αποκλεισμός από σχόλιο

Έλεγχος αποκλεισμένων σχολίων

Σχόλια

Σχόλια για χρήστη

Ρυθμίσεις τομέα

Πρότυπα email

Αρχείο συμβάντων

Δημοσιεύσεις ροής

Σημείωση σχολίου

GIF

Ετικέτες

Συντονισμός

Συντονιστές

Αριθμός ειδοποιήσεων

Ειδοποιήσεις

Αντιδράσεις σε σελίδα

Σελίδες

Εκκρεμή webhook συμβάντα

Ρυθμίσεις ερωτήσεων

Αποτελέσματα ερωτήσεων

Σύνοψη αποτελεσμάτων ερωτήσεων

Χρήστες SSO

Συνδρομές

Καθημερινή χρήση ενοικιαστή

Πακέτα ενοικιαστή

Χρήστες ενοικιαστή

Ενοικιαστές

Αιτήματα

Μεταφράσεις

Ανέβασμα εικόνας

Πρόοδος σήματος χρήστη

Σήματα χρήστη

Ειδοποιήσεις χρήστη

Κατάσταση παρουσίας χρήστη

Αναζήτηση χρηστών

Χρήστες

Ψήφοι

FastComments C++ SDK

Αποθετήριο

Πράκτορες κώδικα AI

Απαιτήσεις

Εγκατάσταση

Εγκατάσταση Εξαρτήσεων

Κατασκευή από Πηγή

Εγκατάσταση

Περιεχόμενα Βιβλιοθήκης

Δημόσια vs Ασφαλή API

Γρήγορη εκκίνηση

Χρήση Πιστοποιημένων API (DefaultAPI)

Χρήση Δημόσιων API (PublicAPI)

Χρήση API Συντονισμού (ModerationApi)

Κοινά Προβλήματα

Κλήσεις API: Συγχρονικές vs Ασύγχρονες

Συγχρονικές κλήσεις με .get()

Ασύγχρονες κλήσεις με .then()

Επιλογή μεταξύ Συγχρονισμού και Ασύγχρονης Εκτέλεσης

Σημειώσεις

Αναγνωριστικά Broadcast

SSO (Ενιαία Σύνδεση)

Χρήση SSO

Απλό SSO

Ασφαλές SSO

Τεκμηρίωση για fastcomments

Documentation for API Endpoints

Documentation for Models

Documentation for Authorization

api_key

Σύνολο

Παράμετροι

Απόκριση

Παράδειγμα

Λήψη αρχείων ελέγχου

Συγχρονικές κλήσεις με `.get()`

Ασύγχρονες κλήσεις με `.then()`