FastComments C++ SDK

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

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

Αποθετήριο

Απαιτήσεις

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

Εγκατάσταση

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

sudo apt install libcpprest-dev libboost-all-dev

Κατασκευή από Πηγαίο Κώδικα

mkdir build
cd build
cmake ..
make

Εγκατάσταση

sudo make install

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

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

Τεκμηρίωση Βιβλιοθήκης Πελάτη API

Δημόσια vs Προστατευμένα API

Για τον πελάτη API, υπάρχουν δύο κλάσεις, DefaultAPI και PublicAPI. Η DefaultAPI περιέχει μεθόδους που απαιτούν το κλειδί API σας, και PublicAPI περιέχει api calls that can be made directly from a browser/mobile device/etc without authentication.

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

Χρήση Επαληθευμένων API (DefaultAPI)

Σημαντικό:

Πρέπει να ορίσετε τη βασική διεύθυνση URL (cpp-restsdk generator doesn't read it from the 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"));  // ΕΕ

    // ΑΠΑΡΑΙΤΗΤΟ: Ορίστε το κλειδί 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)

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

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

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

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

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

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

Συνηθισμένα Προβλήματα

"URI must contain a hostname" error: Βεβαιωθείτε ότι καλείτε config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) πριν δημιουργήσετε το ApiClient. Ο cpp-restsdk generator δεν διαβάζει αυτόματα τη διεύθυνση του server από το OpenAPI spec.
401 "missing-api-key" error: Βεβαιωθείτε ότι καλείτε config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) πριν δημιουργήσετε το instance του DefaultAPI.
Wrong API class: Χρησιμοποιήστε DefaultAPI για server-side αιτήματα που απαιτούν έλεγχο ταυτότητας, PublicAPI για client-side/δημόσια αιτήματα.

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

All API methods in this SDK return pplx::task<std::shared_ptr<ResponseType>> from the C++ REST SDK. Αυτό σας δίνει ευελιξία στον τρόπο που χειρίζεστε τις απαντήσεις του API.

Συγχρονικές κλήσεις με `.get()`

Χρησιμοποιήστε .get() για να μπλοκάρετε το νήμα που καλεί μέχρι να ολοκληρωθεί το αίτημα και να λάβετε το αποτέλεσμα συγχρονικά:

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

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

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

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

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

Χρησιμοποιήστε .then() για μη αποκλειστική ασύγχρονη εκτέλεση με 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);

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

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

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

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

.get() (Συγχρονικό — μπλοκάρισμα)

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

.then() (Ασύγχρονο — μη αποκλειστικό)

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

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

Σημειώσεις

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

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

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

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

Χρήση SSO

Απλό SSO

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

using namespace fastcomments::sso;

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

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

Ασφαλές SSO

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

using namespace fastcomments::sso;

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

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

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

Τεκμηρίωση για το FastComments

Τεκμηρίωση για τα API Endpoints

Όλα τα URI είναι σχετικοί με το https://fastcomments.com

Κλάση	Μέθοδος	HTTP αίτημα	Περιγραφή
DefaultApi	addDomainConfig	POST /api/v1/domain-configs
DefaultApi	addHashTag	POST /api/v1/hash-tags
DefaultApi	addHashTagsBulk	POST /api/v1/hash-tags/bulk
DefaultApi	addPage	POST /api/v1/pages
DefaultApi	addSSOUser	POST /api/v1/sso-users
DefaultApi	aggregate	POST /api/v1/aggregate	Ομαδοποιεί τα έγγραφα και εφαρμόζει πολλαπλές λειτουργίες (αν δοθεί το groupBy). Υποστηρίζονται διάφορες λειτουργίες (π.χ. άθροισμα, countDistinct, avg, κτλ.).
DefaultApi	aggregateQuestionResults	GET /api/v1/question-results-aggregation
DefaultApi	blockUserFromComment	POST /api/v1/comments/{id}/block
DefaultApi	bulkAggregateQuestionResults	POST /api/v1/question-results-aggregation/bulk
DefaultApi	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	createUserBadge	POST /api/v1/user-badges
DefaultApi	createVote	POST /api/v1/votes
DefaultApi	deleteComment	DELETE /api/v1/comments/{id}
DefaultApi	deleteDomainConfig	DELETE /api/v1/domain-configs/{domain}
DefaultApi	deleteEmailTemplate	DELETE /api/v1/email-templates/{id}
DefaultApi	deleteEmailTemplateRenderError	DELETE /api/v1/email-templates/{id}/render-errors/{errorId}
DefaultApi	deleteHashTag	DELETE /api/v1/hash-tags/{tag}
DefaultApi	deleteModerator	DELETE /api/v1/moderators/{id}
DefaultApi	deleteNotificationCount	DELETE /api/v1/notification-count/{id}
DefaultApi	deletePage	DELETE /api/v1/pages/{id}
DefaultApi	deletePendingWebhookEvent	DELETE /api/v1/pending-webhook-events/{id}
DefaultApi	deleteQuestionConfig	DELETE /api/v1/question-configs/{id}
DefaultApi	deleteQuestionResult	DELETE /api/v1/question-results/{id}
DefaultApi	deleteSSOUser	DELETE /api/v1/sso-users/{id}
DefaultApi	deleteSubscription	DELETE /api/v1/subscriptions/{id}
DefaultApi	deleteTenant	DELETE /api/v1/tenants/{id}
DefaultApi	deleteTenantPackage	DELETE /api/v1/tenant-packages/{id}
DefaultApi	deleteTenantUser	DELETE /api/v1/tenant-users/{id}
DefaultApi	deleteUserBadge	DELETE /api/v1/user-badges/{id}
DefaultApi	deleteVote	DELETE /api/v1/votes/{id}
DefaultApi	flagComment	POST /api/v1/comments/{id}/flag
DefaultApi	getAuditLogs	GET /api/v1/audit-logs
DefaultApi	getCachedNotificationCount	GET /api/v1/notification-count/{id}
DefaultApi	getComment	GET /api/v1/comments/{id}
DefaultApi	getComments	GET /api/v1/comments
DefaultApi	getDomainConfig	GET /api/v1/domain-configs/{domain}
DefaultApi	getDomainConfigs	GET /api/v1/domain-configs
DefaultApi	getEmailTemplate	GET /api/v1/email-templates/{id}
DefaultApi	getEmailTemplateDefinitions	GET /api/v1/email-templates/definitions
DefaultApi	getEmailTemplateRenderErrors	GET /api/v1/email-templates/{id}/render-errors
DefaultApi	getEmailTemplates	GET /api/v1/email-templates
DefaultApi	getFeedPosts	GET /api/v1/feed-posts	απαιτείται tenantId afterId
DefaultApi	getHashTags	GET /api/v1/hash-tags
DefaultApi	getModerator	GET /api/v1/moderators/{id}
DefaultApi	getModerators	GET /api/v1/moderators
DefaultApi	getNotificationCount	GET /api/v1/notifications/count
DefaultApi	getNotifications	GET /api/v1/notifications
DefaultApi	getPageByURLId	GET /api/v1/pages/by-url-id
DefaultApi	getPages	GET /api/v1/pages
DefaultApi	getPendingWebhookEventCount	GET /api/v1/pending-webhook-events/count
DefaultApi	getPendingWebhookEvents	GET /api/v1/pending-webhook-events
DefaultApi	getQuestionConfig	GET /api/v1/question-configs/{id}
DefaultApi	getQuestionConfigs	GET /api/v1/question-configs
DefaultApi	getQuestionResult	GET /api/v1/question-results/{id}
DefaultApi	getQuestionResults	GET /api/v1/question-results
DefaultApi	getSSOUserByEmail	GET /api/v1/sso-users/by-email/{email}
DefaultApi	getSSOUserById	GET /api/v1/sso-users/by-id/{id}
DefaultApi	getSSOUsers	GET /api/v1/sso-users
DefaultApi	getSubscriptions	GET /api/v1/subscriptions
DefaultApi	getTenant	GET /api/v1/tenants/{id}
DefaultApi	getTenantDailyUsages	GET /api/v1/tenant-daily-usage
DefaultApi	getTenantPackage	GET /api/v1/tenant-packages/{id}
DefaultApi	getTenantPackages	GET /api/v1/tenant-packages
DefaultApi	getTenantUser	GET /api/v1/tenant-users/{id}
DefaultApi	getTenantUsers	GET /api/v1/tenant-users
DefaultApi	getTenants	GET /api/v1/tenants
DefaultApi	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	updateTenant	PATCH /api/v1/tenants/{id}
DefaultApi	updateTenantPackage	PATCH /api/v1/tenant-packages/{id}
DefaultApi	updateTenantUser	PATCH /api/v1/tenant-users/{id}
DefaultApi	updateUserBadge	PUT /api/v1/user-badges/{id}
PublicApi	blockFromCommentPublic	POST /block-from-comment/{commentId}
PublicApi	checkedCommentsForBlocked	GET /check-blocked-comments
PublicApi	createCommentPublic	POST /comments/{tenantId}
PublicApi	createFeedPostPublic	POST /feed-posts/{tenantId}
PublicApi	deleteCommentPublic	DELETE /comments/{tenantId}/{commentId}
PublicApi	deleteCommentVote	DELETE /comments/{tenantId}/{commentId}/vote/{voteId}
PublicApi	deleteFeedPostPublic	DELETE /feed-posts/{tenantId}/{postId}
PublicApi	flagCommentPublic	POST /flag-comment/{commentId}
PublicApi	getCommentText	GET /comments/{tenantId}/{commentId}/text
PublicApi	getCommentVoteUserNames	GET /comments/{tenantId}/{commentId}/votes
PublicApi	getCommentsPublic	GET /comments/{tenantId}	απαιτείται tenantId urlId
PublicApi	getEventLog	GET /event-log/{tenantId}	απαιτείται tenantId urlId userIdWS
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	απαιτείται tenantId afterId
PublicApi	getFeedPostsStats	GET /feed-posts/{tenantId}/stats
PublicApi	getGlobalEventLog	GET /event-log/global/{tenantId}	απαιτείται tenantId urlId userIdWS
PublicApi	getUserNotificationCount	GET /user-notifications/get-count
PublicApi	getUserNotifications	GET /user-notifications
PublicApi	getUserPresenceStatuses	GET /user-presence-status
PublicApi	getUserReactsPublic	GET /feed-posts/{tenantId}/user-reacts
PublicApi	lockComment	POST /comments/{tenantId}/{commentId}/lock
PublicApi	pinComment	POST /comments/{tenantId}/{commentId}/pin
PublicApi	reactFeedPostPublic	POST /feed-posts/{tenantId}/react/{postId}
PublicApi	resetUserNotificationCount	POST /user-notifications/reset-count
PublicApi	resetUserNotifications	POST /user-notifications/reset
PublicApi	searchUsers	GET /user-search/{tenantId}
PublicApi	setCommentText	POST /comments/{tenantId}/{commentId}/update-text
PublicApi	unBlockCommentPublic	DELETE /block-from-comment/{commentId}
PublicApi	unLockComment	POST /comments/{tenantId}/{commentId}/unlock
PublicApi	unPinComment	POST /comments/{tenantId}/{commentId}/unpin
PublicApi	updateFeedPostPublic	PUT /feed-posts/{tenantId}/{postId}
PublicApi	updateUserNotificationCommentSubscriptionStatus	POST /user-notifications/{notificationId}/mark-opted/{optedInOrOut}	Ενεργοποίηση ή απενεργοποίηση ειδοποιήσεων για συγκεκριμένο σχόλιο.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Ενεργοποίηση ή απενεργοποίηση ειδοποιήσεων για μία σελίδα. Όταν οι χρήστες είναι εγγεγραμμένοι σε μια σελίδα, δημιουργούνται ειδοποιήσεις για νέα βασικά σχόλια και επίσης
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Ανέβασμα και αλλαγή μεγέθους εικόνας
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

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

Συγκέντρωση

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
aggregationRequest	AggregationRequest	Ναι
parentTenantId	string	Όχι
includeStats	bool	Όχι

Απόκριση

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

Παράδειγμα

aggregate Παράδειγμα

Copy

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

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

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
limit	double	Όχι
skip	double	Όχι
order	SORT_DIR	Όχι
after	double	Όχι
before	double	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα getAuditLogs

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα blockFromCommentPublic

Copy

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

Κατάργηση αποκλεισμού δημοσίου σχολίου

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα unBlockCommentPublic

Copy

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

Έλεγχος σχολίων για αποκλεισμό

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα checkedCommentsForBlocked

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

blockUserFromComment Παράδειγμα

Copy

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

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

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
urlId	string	Ναι
broadcastId	string	Ναι
commentData	CommentData	Ναι
sessionId	string	Όχι
sso	string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα createCommentPublic

Copy

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

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

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
id	string	Ναι
contextUserId	string	Όχι
isLive	bool	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα deleteComment

Copy

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

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

Παράμετροι

Όνομα	Type	Απαραίτητο
tenantId	string	Ναι
commentId	string	Ναι
broadcastId	string	Ναι
editKey	string	Όχι
sso	string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα deleteCommentPublic

Copy

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

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

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
commentId	string	Ναι
voteId	string	Ναι
urlId	string	Ναι
broadcastId	string	Ναι
editKey	string	Όχι
sso	string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα deleteCommentVote

Copy

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

Σήμανση σχολίου

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα flagComment

Copy

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

Λήψη σχολίου

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getComment

Copy

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

Λήψη σχολίων

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
page	int32_t	Όχι
limit	int32_t	Όχι
skip	int32_t	Όχι
asTree	bool	Όχι
skipChildren	int32_t	Όχι
limitChildren	int32_t	Όχι
maxTreeDepth	int32_t	Όχι
urlId	string	Όχι
userId	string	Όχι
anonUserId	string	Όχι
contextUserId	string	Όχι
hashTag	string	Όχι
parentId	string	Όχι
direction	SortDirections	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα getComments

Copy

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

Λήψη δημόσιων σχολίων

req tenantId urlId

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
urlId	string	Ναι
page	int32_t	Όχι
direction	SortDirections	Όχι
sso	string	Όχι
skip	int32_t	Όχι
skipChildren	int32_t	Όχι
limit	int32_t	Όχι
limitChildren	int32_t	Όχι
countChildren	bool	Όχι
fetchPageForCommentId	string	Όχι
includeConfig	bool	Όχι
countAll	bool	Όχι
includei10n	bool	Όχι
locale	string	Όχι
modules	string	Όχι
isCrawler	bool	Όχι
includeNotificationCount	bool	Όχι
asTree	bool	Όχι
maxTreeDepth	int32_t	Όχι
useFullTranslationIds	bool	Όχι
parentId	string	Όχι
searchText	string	Όχι
hashTags	vector<string	Όχι
userId	string	Όχι
customConfigStr	string	Όχι
afterCommentId	string	Όχι
beforeCommentId	string	Όχι

Απόκριση

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

Παράδειγμα

getCommentsPublic Παράδειγμα

Copy

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

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

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
commentId	string	Ναι
editKey	string	Όχι
sso	string	Όχι

Απάντηση

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

Παράδειγμα

Παράδειγμα getCommentText

Copy

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

Λήψη ονομάτων χρηστών που ψήφισαν σχόλιο

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα getCommentVoteUserNames

Copy

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

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

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
commentId	string	Ναι
broadcastId	string	Ναι
sso	string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα lockComment

Copy

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

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

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα pinComment

Copy

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

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

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
createCommentParams	CreateCommentParams	Ναι
isLive	bool	Όχι
doSpamCheck	bool	Όχι
sendEmails	bool	Όχι
populateNotifications	bool	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα saveComment

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα setCommentText

Copy

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

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

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
id	string	Ναι
unBlockFromCommentParams	UnBlockFromCommentParams	Ναι
userId	string	Όχι
anonUserId	string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα unBlockUserFromComment

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

unFlagComment Παράδειγμα

Copy

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

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

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα unLockComment

Copy

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

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

Παράμετροι

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

Απάντηση

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

Παράδειγμα

unPinComment Παράδειγμα

Copy

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

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

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
id	string	Ναι
updatableCommentParams	UpdatableCommentParams	Ναι
contextUserId	string	Όχι
doSpamCheck	bool	Όχι
isLive	bool	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα updateComment

Copy

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

Ψήφος σε σχόλιο

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα voteComment

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα addDomainConfig

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα deleteDomainConfig

Copy

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

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

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα getDomainConfig

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

getDomainConfigs Παράδειγμα

Copy

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

Τροποποίηση ρύθμισης τομέα (patch)

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα patchDomainConfig

Copy

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

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

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα putDomainConfig

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα createEmailTemplate

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα deleteEmailTemplate

Copy

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

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

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
id	string	Ναι
errorId	string	Ναι

Απάντηση

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

Παράδειγμα

Παράδειγμα deleteEmailTemplateRenderError

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getEmailTemplate

Copy

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

Λήψη ορισμών προτύπων Email

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα getEmailTemplateDefinitions

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getEmailTemplateRenderErrors

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getEmailTemplates

Copy

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

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

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
renderEmailTemplateBody	RenderEmailTemplateBody	Ναι
locale	string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα renderEmailTemplate

Copy

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

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

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα updateEmailTemplate

Copy

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

Λήψη αρχείου καταγραφής γεγονότων

req tenantId urlId userIdWS

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getEventLog

Copy

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

Λήψη παγκόσμιας καταγραφής γεγονότων

req tenantId urlId userIdWS

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getGlobalEventLog

Copy

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

Δημιουργία ανάρτησης Feed

Parameters

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
createFeedPostParams	CreateFeedPostParams	Ναι
broadcastId	string	Όχι
isLive	bool	Όχι
doSpamCheck	bool	Όχι
skipDupCheck	bool	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα createFeedPost

Copy

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

Δημιουργία δημόσιας ανάρτησης Feed

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα createFeedPostPublic

Copy

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

Διαγραφή δημόσιας ανάρτησης Feed

Παράμετροι

Όνομα	Τύπος	Απαραίτητο
tenantId	string	Ναι
postId	string	Ναι
broadcastId	string	Όχι
sso	string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα deleteFeedPostPublic

Copy

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

Λήψη αναρτήσεων Feed

Παράμετροι

Όνομα	Τύπος	Απαραίτητο
tenantId	string	Ναι
afterId	string	Όχι
limit	int32_t	Όχι
tags	vector<string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα getFeedPosts

Copy

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

Λήψη δημόσιων αναρτήσεων Feed

req tenantId afterId

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
afterId	string	Όχι
limit	int32_t	Όχι
tags	vector<string	Όχι
sso	string	Όχι
isCrawler	bool	Όχι
includeUserInfo	bool	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα getFeedPostsPublic

Copy

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

Λήψη στατιστικών αναρτήσεων Feed

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
postIds	vector<string	Ναι
sso	string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα getFeedPostsStats

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getUserReactsPublic

Copy

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

Αντίδραση σε δημόσια ανάρτηση Feed

Παράμετροι

Όνομα	Τύπος	Απαραίτητο
tenantId	string	Ναι
postId	string	Ναι
reactBodyParams	ReactBodyParams	Ναι
isUndo	bool	Όχι
broadcastId	string	Όχι
sso	string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα reactFeedPostPublic

Copy

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

Ενημέρωση ανάρτησης Feed

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
id	string	Ναι
feedPost	FeedPost	Ναι

Απόκριση

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

Παράδειγμα

Παράδειγμα updateFeedPost

Copy

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

Ενημέρωση δημόσιας ανάρτησης Feed

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα updateFeedPostPublic

Copy

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

Σήμανση δημόσιου σχολίου

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα flagCommentPublic

Copy

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

Προσθήκη hashtag

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα addHashTag

Copy

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

Μαζική προσθήκη hashtags

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα addHashTagsBulk

Copy

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

Διαγραφή hashtag

Παράμετροι

Name	Type	Required
tag	string	Ναι
tenantId	string	Όχι
deleteHashTagRequest	DeleteHashTag_request	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα deleteHashTag

Copy

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

Λήψη hashtags

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getHashTags

Copy

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

Τροποποίηση hashtag

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα patchHashTag

Copy

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

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

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα createModerator

Copy

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

Διαγραφή διαχειριστή

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα deleteModerator

Copy

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

Λήψη διαχειριστή

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getModerator

Copy

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

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

Παράμετροι

Name	Type	Required	Description
tenantId	string	Ναι
skip	double	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα getModerators

Copy

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

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

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
id	string	Ναι
fromName	string	Ναι

Απόκριση

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

Παράδειγμα

Παράδειγμα sendInvite

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα updateModerator

Copy

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

Διαγραφή μετρητή ειδοποιήσεων

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα deleteNotificationCount

Copy

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

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

Παράμετροι

Name	Type	Required	Description
tenantId	string	Ναι
id	string	Ναι

Απόκριση

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

Παράδειγμα

Παράδειγμα getCachedNotificationCount

Copy

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

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

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
userId	string	Όχι
urlId	string	Όχι
fromCommentId	string	Όχι
viewed	bool	Όχι
type	string	Όχι

Απάντηση

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

Παράδειγμα

Παράδειγμα getNotificationCount

Copy

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

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

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
userId	string	Όχι
urlId	string	Όχι
fromCommentId	string	Όχι
viewed	bool	Όχι
type	string	Όχι
skip	double	Όχι

Απάντηση

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

Παράδειγμα

Παράδειγμα getNotifications

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα updateNotification

Copy

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

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

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα addPage

Copy

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

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

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα deletePage

Copy

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

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

Παράμετροι

Name	Type	Required	Description
tenantId	string	Ναι
urlId	string	Ναι

Απάντηση

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

Παράδειγμα

getPageByURLId Παράδειγμα

Copy

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

Λήψη σελίδων

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα getPages

Copy

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

Τροποποίηση σελίδας

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
id	string	Ναι
updateAPIPageData	UpdateAPIPageData	Ναι

Απόκριση

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

Παράδειγμα

Παράδειγμα patchPage

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα deletePendingWebhookEvent

Copy

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

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

Παράμετροι

Όνομα	Τύπος	Υποχρεωτικό
tenantId	string	Ναι
commentId	string	Όχι
externalId	string	Όχι
eventType	string	Όχι
type	string	Όχι
domain	string	Όχι
attemptCountGT	double	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα getPendingWebhookEventCount

Copy

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

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

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
commentId	string	Όχι
externalId	string	Όχι
eventType	string	Όχι
type	string	Όχι
domain	string	Όχι
attemptCountGT	double	Όχι
skip	double	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα getPendingWebhookEvents

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

createQuestionConfig Παράδειγμα

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα deleteQuestionConfig

Copy

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

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

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα getQuestionConfig

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getQuestionConfigs

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα updateQuestionConfig

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα createQuestionResult

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα deleteQuestionResult

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getQuestionResult

Copy

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

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

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
urlId	string	Όχι
userId	string	Όχι
startDate	string	Όχι
questionId	string	Όχι
questionIds	string	Όχι
skip	double	Όχι

Απάντηση

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

Παράδειγμα

Παράδειγμα getQuestionResults

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα updateQuestionResult

Copy

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

Συγκέντρωση αποτελεσμάτων ερωτήσεων

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
questionId	string	Όχι
questionIds	vector<string	Όχι
urlId	string	Όχι
timeBucket	AggregateTimeBucket	Όχι
startDate	datetime	Όχι
forceRecalculate	bool	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα aggregateQuestionResults

Copy

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

Μαζική συγκέντρωση αποτελεσμάτων ερωτήσεων

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα bulkAggregateQuestionResults

Copy

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

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

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
questionId	string	Όχι
questionIds	vector<string	Όχι
urlId	string	Όχι
startDate	datetime	Όχι
forceRecalculate	bool	Όχι
minValue	double	Όχι
maxValue	double	Όχι
limit	double	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα combineCommentsWithQuestionResults

Copy

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

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

Παράμετροι

Name	Type	Required	Description
tenantId	string	Ναι
createAPISSOUserData	CreateAPISSOUserData	Ναι

Απόκριση

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

Παράδειγμα

Παράδειγμα addSSOUser

Copy

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

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

Παράμετροι

Όνομα	Τύπος	Απαραίτητο
tenantId	string	Ναι
id	string	Ναι
deleteComments	bool	Όχι
commentDeleteMode	string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα deleteSSOUser

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getSSOUserByEmail

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getSSOUserById

Copy

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

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

Παράμετροι

Name	Type	Required	Description
tenantId	string	Ναι
skip	int32_t	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα getSSOUsers

Copy

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

Τροποποίηση χρήστη SSO

Παράμετροι

Όνομα	Τύπος	Απαραίτητο
tenantId	string	Ναι
id	string	Ναι
updateAPISSOUserData	UpdateAPISSOUserData	Ναι
updateComments	bool	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα patchSSOUser

Copy

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

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

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
id	string	Ναι
updateAPISSOUserData	UpdateAPISSOUserData	Ναι
updateComments	bool	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα putSSOUser

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα createSubscription

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα deleteSubscription

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getSubscriptions

Copy

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

Λήψη ημερήσιας χρήσης tenant

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
yearNumber	double	Όχι
monthNumber	double	Όχι
dayNumber	double	Όχι
skip	double	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα getTenantDailyUsages

Copy

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

Δημιουργία πακέτου tenant

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα createTenantPackage

Copy

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

Διαγραφή πακέτου tenant

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα deleteTenantPackage

Copy

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

Λήψη πακέτου tenant

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getTenantPackage

Copy

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

Λήψη πακέτων tenant

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getTenantPackages

Copy

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

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

Παράμετροι

Όνομα	Τύπος	Υποχρεωτικό
tenantId	string	Ναι
id	string	Ναι
replaceTenantPackageBody	ReplaceTenantPackageBody	Ναι

Απάντηση

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

Παράδειγμα

Παράδειγμα replaceTenantPackage

Copy

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

Ενημέρωση πακέτου tenant

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα updateTenantPackage

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα createTenantUser

Copy

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

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

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
id	string	Ναι
deleteComments	string	Όχι
commentDeleteMode	string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα deleteTenantUser

Copy

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

Λήψη χρήστη tenant

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getTenantUser

Copy

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

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

Παράμετροι

Name	Type	Required	Description
tenantId	string	Ναι
skip	double	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα getTenantUsers

Copy

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

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

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα replaceTenantUser

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα sendLoginLink

Copy

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

Ενημέρωση χρήστη tenant

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα updateTenantUser

Copy

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

Δημιουργία tenant

Παράμετροι

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

Απόκριση

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

Παράδειγμα

createTenant Παράδειγμα

Copy

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

Διαγραφή tenant

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα deleteTenant

Copy

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

Λήψη tenant

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα getTenant

Copy

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

Λήψη tenants

Παράμετροι

Όνομα	Type	Απαιτείται
tenantId	string	Ναι
meta	string	Όχι
skip	double	Όχι

Απάντηση

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

Παράδειγμα

Παράδειγμα getTenants

Copy

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

Ενημέρωση tenant

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα updateTenant

Copy

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

Μεταφόρτωση εικόνας

Μεταφόρτωση και αλλαγή μεγέθους εικόνας

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
file	HttpContent	Ναι
sizePreset	SizePreset	Όχι
urlId	string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα uploadImage

Copy

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

Λήψη προόδου διακριτικού χρήστη με ID

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getUserBadgeProgressById

Copy

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

Λήψη προόδου διακριτικού με ID χρήστη

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getUserBadgeProgressByUserId

Copy

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

Λήψη λίστας προόδου διακριτικών χρήστη

Παράμετροι

Όνομα	Τύπος	Απαραίτητο
tenantId	string	Ναι
userId	string	Όχι
limit	double	Όχι
skip	double	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα getUserBadgeProgressList

Copy

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

Δημιουργία διακριτικού χρήστη

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα createUserBadge

Copy

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

Διαγραφή διακριτικού χρήστη

Παράμετροι

Name	Type	Required	Description
tenantId	string	Ναι
id	string	Ναι

Απόκριση

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

Παράδειγμα

deleteUserBadge Παράδειγμα

Copy

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

Λήψη διακριτικού χρήστη

Παράμετροι

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

Απάντηση

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

Παράδειγμα

getUserBadge Παράδειγμα

Copy

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

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

Παράμετροι

Όνομα	Type	Απαιτείται
tenantId	string	Ναι
userId	string	Όχι
badgeId	string	Όχι
type	double	Όχι
displayedOnComments	bool	Όχι
limit	double	Όχι
skip	double	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα getUserBadges

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα updateUserBadge

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getUserNotificationCount

Copy

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

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

Παράμετροι

Όνομα	Τύπος	Απαραίτητο
tenantId	string	Ναι
pageSize	int32_t	Όχι
afterId	string	Όχι
includeContext	bool	Όχι
afterCreatedAt	int64_t	Όχι
unreadOnly	bool	Όχι
dmOnly	bool	Όχι
noDm	bool	Όχι
includeTranslations	bool	Όχι
sso	string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα getUserNotifications

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα resetUserNotificationCount

Copy

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

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

Παράμετροι

Όνομα	Τύπος	Απαιτείται
tenantId	string	Ναι
afterId	string	Όχι
afterCreatedAt	int64_t	Όχι
unreadOnly	bool	Όχι
dmOnly	bool	Όχι
noDm	bool	Όχι
sso	string	Όχι

Απάντηση

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

Παράδειγμα

Παράδειγμα resetUserNotifications

Copy

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

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

Ενεργοποίηση ή απενεργοποίηση ειδοποιήσεων για ένα συγκεκριμένο σχόλιο.

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα updateUserNotificationCommentSubscriptionStatus

Copy

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

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

Ενεργοποιήστε ή απενεργοποιήστε τις ειδοποιήσεις για μια σελίδα. Όταν οι χρήστες είναι εγγεγραμμένοι σε μια σελίδα, δημιουργούνται ειδοποιήσεις για νέα κύρια σχόλια, και επίσης

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα updateUserNotificationPageSubscriptionStatus

Copy

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

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

Παράμετροι

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

Απάντηση

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

Παράδειγμα

Παράδειγμα updateUserNotificationStatus

Copy

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

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

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
urlIdWS	string	Ναι
userIds	string	Ναι

Απάντηση

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

Παράδειγμα

Παράδειγμα getUserPresenceStatuses

Copy

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

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

Παράμετροι

Όνομα	Τύπος	Απαραίτητο
tenantId	string	Ναι
urlId	string	Ναι
usernameStartsWith	string	Όχι
mentionGroupIds	vector<string	Όχι
sso	string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα searchUsers

Copy

utility::string_t tenantId = utility::string_t("my-tenant-123");
utility::string_t urlId = utility::string_t("/posts/2026/new-feature");
boost::optional<utility::string_t> usernameStartsWith = boost::optional<utility::string_t>(utility::string_t("alex"));
boost::optional<std::vector<utility::string_t>> mentionGroupIds{std::vector<utility::string_t>{utility::string_t("ops-team"), utility::string_t("support")}};
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(utility::string_t("saml-idp"));
api->searchUsers(tenantId, urlId, usernameStartsWith, mentionGroupIds, sso)
    .then([](pplx::task<std::shared_ptr<SearchUsers_200_response>> t){
        try {
            auto resp = t.get();
            if (!resp) resp = std::make_shared<SearchUsers_200_response>();
        } catch (...) {}
    });

Λήψη χρήστη

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getUser

Copy

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

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

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
commentId	string	Ναι
direction	string	Ναι
userId	string	Όχι
anonUserId	string	Όχι

Απάντηση

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

Παράδειγμα

Παράδειγμα createVote

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα deleteVote

Copy

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

Λήψη ψήφων

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getVotes

Copy

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

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

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getVotesForUser

Copy

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

Χρειάζεστε βοήθεια;

Εάν αντιμετωπίσετε οποιοδήποτε πρόβλημα ή έχετε απορίες σχετικά με το C++ SDK, παρακαλώ:

Συνεισφορές

Οι συνεισφορές είναι ευπρόσδεκτες! Παρακαλούμε επισκεφθείτε το αποθετήριο στο GitHub για τις οδηγίες συνεισφοράς.

Γλώσσα 🇨🇾 Ελληνικά (Κύπρος)

Τεκμηρίωση

Εισαγωγή

Αναφορά API

Χρήση

Συγκέντρωση

Αρχεία ελέγχου

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

Έλεγχος αποκλεισμένων σχολίων

Σχόλια

Ρυθμίσεις τομέα

Πρότυπα Email

Καταγραφή γεγονότων

Αναρτήσεις Feed

Σήμανση σχολίου

Hashtags

Διαχειριστές

Μετρητής ειδοποιήσεων

Ειδοποιήσεις

Σελίδες

Εκκρεμή συμβάντα webhook

Ρυθμίσεις ερωτήσεων

Αποτελέσματα ερωτήσεων

Συσσωμάτωση αποτελεσμάτων ερωτήσεων

Χρήστες SSO

Συνδρομές

Ημερήσια χρήση tenant

Πακέτα tenant

Χρήστες tenant

Tenants

Μεταφόρτωση εικόνας

Πρόοδος διακριτικών χρήστη

Διακριτικά χρήστη

Ειδοποιήσεις χρήστη

Κατάσταση παρουσίας χρήστη

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

Χρήστες

Ψηφοφορίες

FastComments C++ SDK

Αποθετήριο

Απαιτήσεις

Εγκατάσταση

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

Κατασκευή από Πηγαίο Κώδικα

Εγκατάσταση

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

Δημόσια vs Προστατευμένα API

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

Χρήση Επαληθευμένων API (DefaultAPI)

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

Συνηθισμένα Προβλήματα

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

Συγχρονικές κλήσεις με .get()

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

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

Σημειώσεις

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

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

Χρήση SSO

Απλό SSO

Ασφαλές SSO

Τεκμηρίωση για το FastComments

Τεκμηρίωση για τα API Endpoints

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

Συγκέντρωση

Παράμετροι

Απόκριση

Παράδειγμα

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

Παράμετροι

Απόκριση

Παράδειγμα

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

Παράμετροι

Απόκριση

Παράδειγμα

Κατάργηση αποκλεισμού δημοσίου σχολίου

Παράμετροι

Απάντηση

Παράδειγμα

Συγχρονικές κλήσεις με `.get()`

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