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

Δημόσια έναντι Ασφαλών API

Για τον client του API, υπάρχουν δύο κλάσεις, DefaultAPI και PublicAPI. Η DefaultAPI περιέχει μεθόδους που απαιτούν το API key σας, και η PublicAPI περιέχει κλήσεις API που μπορούν να πραγματοποιηθούν απευθείας από έναν περιηγητή/κινητή συσκευή/κ.λπ. χωρίς πιστοποίηση.

Γρήγορη Έναρξη

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

Σημαντικό:

Πρέπει να ορίσετε τη βασική διεύθυνση URL (ο cpp-restsdk generator δεν τη διαβάζει από το OpenAPI spec)
Πρέπει να ορίσετε το API key σας στο 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
    // OR: config->setBaseUrl(utility::conversions::to_string_t("https://eu.fastcomments.com"));  // EU

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

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

    // Now make authenticated API calls
    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": Βεβαιωθείτε ότι καλείτε config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) πριν δημιουργήσετε το ApiClient. Ο cpp-restsdk generator δεν διαβάζει αυτόματα το server URL από το OpenAPI spec.
Σφάλμα 401 "missing-api-key": Βεβαιωθείτε ότι καλείτε config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) πριν δημιουργήσετε το αντικείμενο DefaultAPI.
Λάθος κλάση API: Χρησιμοποιήστε DefaultAPI για server-side αιτήσεις με αυθεντικοποίηση, PublicAPI για client-side/δημόσιες αιτήσεις.

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

Όλες οι μεθόδοι API σε αυτό το SDK επιστρέφουν pplx::task<std::shared_ptr<ResponseType>> από το 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);

// Καλέστε .get() για να μπλοκάρετε και να λάβετε το αποτέλεσμα συγχρονικά
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();  // Μπλοκάρει μέχρι να ολοκληρωθεί το αίτημα HTTP

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

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

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

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

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

// Χρησιμοποιήστε .then() για ασύγχρονη εκτέλεση με callbacks
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) {
    // Αυτό τρέχει ασύγχρονα όταν το αίτημα ολοκληρωθεί
    if (response && response->comments) {
        std::cout << "Found " << response->comments->size() << " comments" << std::endl;
    }
});

// Η εκτέλεση συνεχίζεται αμέσως χωρίς μπλοκάρισμα
std::cout << "Request sent, continuing..." << std::endl;

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

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

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

Blocks the calling thread until the HTTP request completes
Απλούστερη ροή κώδικα, πιο εύκολο στην κατανόηση
Κατάλληλο για αφιερωμένα worker threads, batch επεξεργασία ή εργαλεία γραμμής εντολών
Δεν είναι κατάλληλο για event loops, GUI threads ή single-threaded servers

.then() (Ασύγχρονο, χωρίς μπλοκάρισμα)

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

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

Σημειώσεις

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

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

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

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

Χρήση SSO

Απλό SSO

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

using namespace fastcomments::sso;

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

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

Ασφαλές SSO

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

using namespace fastcomments::sso;

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

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

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

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

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

Όλα τα URIs είναι σχετικοί προς https://fastcomments.com

Κλάση	Μέθοδος	Αίτημα HTTP	Περιγραφή
DefaultApi	addDomainConfig	POST /api/v1/domain-configs
DefaultApi	addHashTag	POST /api/v1/hash-tags
DefaultApi	addHashTagsBulk	POST /api/v1/hash-tags/bulk
DefaultApi	addPage	POST /api/v1/pages
DefaultApi	addSSOUser	POST /api/v1/sso-users
DefaultApi	aggregate	POST /api/v1/aggregate	Ομαδοποιεί έγγραφα (αν το groupBy έχει οριστεί) και εκτελεί πολλαπλές λειτουργίες. Υποστηρίζονται διάφορες λειτουργίες (π.χ. sum, countDistinct, avg, κ.ά.).
DefaultApi	aggregateQuestionResults	GET /api/v1/question-results-aggregation
DefaultApi	blockUserFromComment	POST /api/v1/comments/{id}/block
DefaultApi	bulkAggregateQuestionResults	POST /api/v1/question-results-aggregation/bulk
DefaultApi	changeTicketState	PATCH /api/v1/tickets/{id}/state
DefaultApi	combineCommentsWithQuestionResults	GET /api/v1/question-results-aggregation/combine/comments
DefaultApi	createEmailTemplate	POST /api/v1/email-templates
DefaultApi	createFeedPost	POST /api/v1/feed-posts
DefaultApi	createModerator	POST /api/v1/moderators
DefaultApi	createQuestionConfig	POST /api/v1/question-configs
DefaultApi	createQuestionResult	POST /api/v1/question-results
DefaultApi	createSubscription	POST /api/v1/subscriptions
DefaultApi	createTenant	POST /api/v1/tenants
DefaultApi	createTenantPackage	POST /api/v1/tenant-packages
DefaultApi	createTenantUser	POST /api/v1/tenant-users
DefaultApi	createTicket	POST /api/v1/tickets
DefaultApi	createUserBadge	POST /api/v1/user-badges
DefaultApi	createVote	POST /api/v1/votes
DefaultApi	deleteComment	DELETE /api/v1/comments/{id}
DefaultApi	deleteDomainConfig	DELETE /api/v1/domain-configs/{domain}
DefaultApi	deleteEmailTemplate	DELETE /api/v1/email-templates/{id}
DefaultApi	deleteEmailTemplateRenderError	DELETE /api/v1/email-templates/{id}/render-errors/{errorId}
DefaultApi	deleteHashTag	DELETE /api/v1/hash-tags/{tag}
DefaultApi	deleteModerator	DELETE /api/v1/moderators/{id}
DefaultApi	deleteNotificationCount	DELETE /api/v1/notification-count/{id}
DefaultApi	deletePage	DELETE /api/v1/pages/{id}
DefaultApi	deletePendingWebhookEvent	DELETE /api/v1/pending-webhook-events/{id}
DefaultApi	deleteQuestionConfig	DELETE /api/v1/question-configs/{id}
DefaultApi	deleteQuestionResult	DELETE /api/v1/question-results/{id}
DefaultApi	deleteSSOUser	DELETE /api/v1/sso-users/{id}
DefaultApi	deleteSubscription	DELETE /api/v1/subscriptions/{id}
DefaultApi	deleteTenant	DELETE /api/v1/tenants/{id}
DefaultApi	deleteTenantPackage	DELETE /api/v1/tenant-packages/{id}
DefaultApi	deleteTenantUser	DELETE /api/v1/tenant-users/{id}
DefaultApi	deleteUserBadge	DELETE /api/v1/user-badges/{id}
DefaultApi	deleteVote	DELETE /api/v1/votes/{id}
DefaultApi	flagComment	POST /api/v1/comments/{id}/flag
DefaultApi	getAuditLogs	GET /api/v1/audit-logs
DefaultApi	getCachedNotificationCount	GET /api/v1/notification-count/{id}
DefaultApi	getComment	GET /api/v1/comments/{id}
DefaultApi	getComments	GET /api/v1/comments
DefaultApi	getDomainConfig	GET /api/v1/domain-configs/{domain}
DefaultApi	getDomainConfigs	GET /api/v1/domain-configs
DefaultApi	getEmailTemplate	GET /api/v1/email-templates/{id}
DefaultApi	getEmailTemplateDefinitions	GET /api/v1/email-templates/definitions
DefaultApi	getEmailTemplateRenderErrors	GET /api/v1/email-templates/{id}/render-errors
DefaultApi	getEmailTemplates	GET /api/v1/email-templates
DefaultApi	getFeedPosts	GET /api/v1/feed-posts	req tenantId afterId
DefaultApi	getHashTags	GET /api/v1/hash-tags
DefaultApi	getModerator	GET /api/v1/moderators/{id}
DefaultApi	getModerators	GET /api/v1/moderators
DefaultApi	getNotificationCount	GET /api/v1/notifications/count
DefaultApi	getNotifications	GET /api/v1/notifications
DefaultApi	getPageByURLId	GET /api/v1/pages/by-url-id
DefaultApi	getPages	GET /api/v1/pages
DefaultApi	getPendingWebhookEventCount	GET /api/v1/pending-webhook-events/count
DefaultApi	getPendingWebhookEvents	GET /api/v1/pending-webhook-events
DefaultApi	getQuestionConfig	GET /api/v1/question-configs/{id}
DefaultApi	getQuestionConfigs	GET /api/v1/question-configs
DefaultApi	getQuestionResult	GET /api/v1/question-results/{id}
DefaultApi	getQuestionResults	GET /api/v1/question-results
DefaultApi	getSSOUserByEmail	GET /api/v1/sso-users/by-email/{email}
DefaultApi	getSSOUserById	GET /api/v1/sso-users/by-id/{id}
DefaultApi	getSSOUsers	GET /api/v1/sso-users
DefaultApi	getSubscriptions	GET /api/v1/subscriptions
DefaultApi	getTenant	GET /api/v1/tenants/{id}
DefaultApi	getTenantDailyUsages	GET /api/v1/tenant-daily-usage
DefaultApi	getTenantPackage	GET /api/v1/tenant-packages/{id}
DefaultApi	getTenantPackages	GET /api/v1/tenant-packages
DefaultApi	getTenantUser	GET /api/v1/tenant-users/{id}
DefaultApi	getTenantUsers	GET /api/v1/tenant-users
DefaultApi	getTenants	GET /api/v1/tenants
DefaultApi	getTicket	GET /api/v1/tickets/{id}
DefaultApi	getTickets	GET /api/v1/tickets
DefaultApi	getUser	GET /api/v1/users/{id}
DefaultApi	getUserBadge	GET /api/v1/user-badges/{id}
DefaultApi	getUserBadgeProgressById	GET /api/v1/user-badge-progress/{id}
DefaultApi	getUserBadgeProgressByUserId	GET /api/v1/user-badge-progress/user/{userId}
DefaultApi	getUserBadgeProgressList	GET /api/v1/user-badge-progress
DefaultApi	getUserBadges	GET /api/v1/user-badges
DefaultApi	getVotes	GET /api/v1/votes
DefaultApi	getVotesForUser	GET /api/v1/votes/for-user
DefaultApi	patchDomainConfig	PATCH /api/v1/domain-configs/{domainToUpdate}
DefaultApi	patchHashTag	PATCH /api/v1/hash-tags/{tag}
DefaultApi	patchPage	PATCH /api/v1/pages/{id}
DefaultApi	patchSSOUser	PATCH /api/v1/sso-users/{id}
DefaultApi	putDomainConfig	PUT /api/v1/domain-configs/{domainToUpdate}
DefaultApi	putSSOUser	PUT /api/v1/sso-users/{id}
DefaultApi	renderEmailTemplate	POST /api/v1/email-templates/render
DefaultApi	replaceTenantPackage	PUT /api/v1/tenant-packages/{id}
DefaultApi	replaceTenantUser	PUT /api/v1/tenant-users/{id}
DefaultApi	saveComment	POST /api/v1/comments
DefaultApi	saveCommentsBulk	POST /api/v1/comments/bulk
DefaultApi	sendInvite	POST /api/v1/moderators/{id}/send-invite
DefaultApi	sendLoginLink	POST /api/v1/tenant-users/{id}/send-login-link
DefaultApi	unBlockUserFromComment	POST /api/v1/comments/{id}/un-block
DefaultApi	unFlagComment	POST /api/v1/comments/{id}/un-flag
DefaultApi	updateComment	PATCH /api/v1/comments/{id}
DefaultApi	updateEmailTemplate	PATCH /api/v1/email-templates/{id}
DefaultApi	updateFeedPost	PATCH /api/v1/feed-posts/{id}
DefaultApi	updateModerator	PATCH /api/v1/moderators/{id}
DefaultApi	updateNotification	PATCH /api/v1/notifications/{id}
DefaultApi	updateQuestionConfig	PATCH /api/v1/question-configs/{id}
DefaultApi	updateQuestionResult	PATCH /api/v1/question-results/{id}
DefaultApi	updateSubscription	PATCH /api/v1/subscriptions/{id}
DefaultApi	updateTenant	PATCH /api/v1/tenants/{id}
DefaultApi	updateTenantPackage	PATCH /api/v1/tenant-packages/{id}
DefaultApi	updateTenantUser	PATCH /api/v1/tenant-users/{id}
DefaultApi	updateUserBadge	PUT /api/v1/user-badges/{id}
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}	req tenantId urlId
PublicApi	getEventLog	GET /event-log/{tenantId}	req tenantId urlId userIdWS
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	req tenantId afterId
PublicApi	getFeedPostsStats	GET /feed-posts/{tenantId}/stats
PublicApi	getGlobalEventLog	GET /event-log/global/{tenantId}	req 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

Τεκμηρίωση για τα Μοντέλα

Συγκέντρωση

Παράμετροι

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

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

Παράμετροι

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

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

Παράμετροι

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

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

Παράμετροι

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

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

Παράμετροι

Name	Type	Required
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

Παράμετροι

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

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

Παράμετροι

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

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

Παράμετροι

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

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

Παράμετροι

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

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

Παράμετροι

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

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

Parameters

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

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

Παράμετροι

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

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

Παράμετροι

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

Απόκριση

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

Παράμετροι

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

Παράμετροι

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

Παράμετροι

Name	Type	Required
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

Παράμετροι

Name	Type	Required
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

Παράμετροι

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

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

Παράμετροι

Name	Type	Required
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

Παράμετροι

Name	Type	Απαιτείται
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

Παράμετροι

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

Παράμετροι

Name	Type	Required	Description
tenantId	string	Όχι
createHashTagBody	CreateHashTagBody	Όχι

Response

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

Παράμετροι

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

Δημιουργία moderator

Παράμετροι

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

Διαγραφή moderator

Παράμετροι

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

Λήψη moderator

Παράμετροι

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

Λήψη moderators

Παράμετροι

Όνομα	Type	Υποχρεωτικό	Περιγραφή
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();

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

Παράμετροι

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

Ενημέρωση moderator

Παράμετροι

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

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

Παράμετροι

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

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

Παράμετροι

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

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

Παράμετροι

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

Απάντηση

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

Παράμετροι

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

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

Παράμετροι

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

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

Παράμετροι

Name	Type	Required
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	Yes
questionId	string	No
questionIds	vector<string	No
urlId	string	No
startDate	datetime	No
forceRecalculate	bool	No
minValue	double	No
maxValue	double	No
limit	double	No

Απόκριση

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

Παράμετροι

Όνομα	Τύπος	Υποχρεωτικό	Περιγραφή
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

Παράμετροι

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

Παράμετροι

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

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

Παράμετροι

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

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

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
id	string	Ναι
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	Ναι
userId	string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα updateSubscription

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t subscriptionId = U("sub-456");
UpdateAPIUserSubscriptionData updateData;
auto fallbackResp = std::make_shared<UpdateSubscriptionAPIResponse>();
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
api->updateSubscription(tenantId, subscriptionId, updateData, userId)
    .then([](pplx::task<std::shared_ptr<UpdateSubscriptionAPIResponse>> task) {
        try {
            auto resp = task.get();
            if (resp) {
                // επεξεργασία του resp
            }
        } catch (const std::exception&) {
        }
    });

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

Παράμετροι

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

Παράμετροι

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

Παράμετροι

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

Παράμετροι

Name	Type	Required	Description
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.displayName = boost::optional<utility::string_t>(utility::conversions::to_string_t("New User"));
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

Παράμετροι

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

Παράμετροι

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

Παράμετροι

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

Αλλαγή κατάστασης ticket

Παράμετροι

Name	Type	Required
tenantId	string	Ναι
userId	string	Ναι
id	string	Ναι
changeTicketStateBody	ChangeTicketStateBody	Ναι

Απόκριση

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

Παράδειγμα

Παράδειγμα changeTicketState

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("support@acme.com");
utility::string_t ticketId = U("ticket-456");
ChangeTicketStateBody changeBody;
changeBody.state = U("closed");
changeBody.note = boost::optional<utility::string_t>(U("Resolved after customer confirmation"));
api->changeTicketState(tenantId, userId, ticketId, changeBody)
.then([](std::shared_ptr<ChangeTicketState_200_response> resp){
    auto copy = std::make_shared<ChangeTicketState_200_response>(*resp);
    return copy;
})
.then([](std::shared_ptr<ChangeTicketState_200_response> finalResp){
    (void)finalResp;
});

Δημιουργία ticket

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα createTicket

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user@example.com");
CreateTicketBody body;
body.subject = U("Checkout failure for order #A123");
body.description = U("Payment declined at gateway for card ending 4242");
body.requesterEmail = userId;
body.priority = boost::optional<int>(2);
body.metadata = boost::optional<utility::string_t>(U("order:A123"));
api->createTicket(tenantId, userId, body).then([](pplx::task<std::shared_ptr<CreateTicket_200_response>> t){
    try {
        auto resp = t.get();
        if (resp) std::cout << "Created ticket id: " << (resp->id.empty() ? U("unknown") : resp->id) << std::endl;
    } catch (const std::exception& e) {
        auto fallback = std::make_shared<CreateTicket_200_response>();
        std::cout << "Failed to create ticket: " << e.what() << std::endl;
    }
});

Λήψη ticket

Παράμετροι

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

Απόκριση

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

Παράδειγμα

getTicket Παράδειγμα

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t ticketId = U("ticket-456");
boost::optional<utility::string_t> userId = boost::optional<utility::string_t>(U("user@example.com"));
auto ticketResult = std::make_shared<GetTicket_200_response>();
api->getTicket(tenantId, ticketId, userId)
    .then([&ticketResult](pplx::task<std::shared_ptr<GetTicket_200_response>> t) {
        try {
            auto resp = t.get();
            if (resp) ticketResult = resp;
        } catch (...) {}
    });

Λήψη tickets

Παράμετροι

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

Απόκριση

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

Παράδειγμα

Παράδειγμα getTickets

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> userId = U("user@example.com");
boost::optional<double> state = 1.0;
boost::optional<double> skip = 0.0;
boost::optional<double> limit = 50.0;
pplx::task<std::shared_ptr<GetTickets_200_response>> t = api->getTickets(tenantId, userId, state, skip, limit)
.then([](pplx::task<std::shared_ptr<GetTickets_200_response>> prev){
    try {
        auto resp = prev.get();
        if(!resp) resp = std::make_shared<GetTickets_200_response>();
        std::cout << "Got tickets response: " << (resp ? "received" : "none") << std::endl;
    } catch (const std::exception &e) {
        std::cerr << "getTickets failed: " << e.what() << std::endl;
    }
});

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

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

Παράμετροι

Name	Type	Required
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

Παράμετροι

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

Λήψη προόδου σήματος χρήστη με user 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&) {
        }
    }
);

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

Παράμετροι

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

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

Παράμετροι

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

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

Παράμετροι

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

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

Παράμετροι

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

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

Παράμετροι

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

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

Παράμετροι

Name	Type	Απαιτείται
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>();
        }
    });

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

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

Παράμετροι

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

Απόκριση

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

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

Παράμετροι

Name	Type	Required
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 (...) {
    }
});

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

Παράμετροι

Όνομα	Τύπος	Απαιτείται
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	Όχι
searchSection	string	Όχι

Απόκριση

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

Παράδειγμα

Παράδειγμα searchUsers

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("https://example.com/articles/987");
boost::optional<utility::string_t> usernameStartsWith = boost::optional<utility::string_t>(U("alice"));
boost::optional<std::vector<utility::string_t>> mentionGroupIds = boost::optional<std::vector<utility::string_t>>({ U("editors"), U("authors") });
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
boost::optional<utility::string_t> searchSection = boost::optional<utility::string_t>(U("main"));
api->searchUsers(tenantId, urlId, usernameStartsWith, mentionGroupIds, sso, searchSection)
.then([](pplx::task<std::shared_ptr<SearchUsers_200_response>> t) {
    try {
        auto resp = t.get();
        auto copied = std::make_shared<SearchUsers_200_response>(*resp);
    } catch (const std::exception&) {
    }
});

Λήψη χρήστη

Παράμετροι

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

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

Παράμετροι

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

Αρχείο καταγραφής συμβάντων

Αναρτήσεις ροής

Αναφορά σχολίου

Hashtags

Συντονιστές

Πλήθος ειδοποιήσεων

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

Σελίδες

Εκκρεμή γεγονότα webhook

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

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

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

Χρήστες SSO

Συνδρομές

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

Πακέτα tenant

Χρήστες tenant

Μισθωτές

Εισιτήρια

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

Πρόοδος σήματος χρήστη

Σήματα χρήστη

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

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

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

Χρήστες

Ψήφοι

FastComments C++ SDK

Αποθετήριο

Απαιτήσεις

Εγκατάσταση

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

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

Εγκατάσταση

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

Δημόσια έναντι Ασφαλών API

Γρήγορη Έναρξη

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

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

Συχνά προβλήματα

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

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

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

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

Σημειώσεις

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

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

Χρήση SSO

Απλό SSO

Ασφαλές SSO

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

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

Τεκμηρίωση για τα Μοντέλα

Συγκέντρωση

Παράμετροι

Απόκριση

Παράδειγμα

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

Παράμετροι

Απόκριση

Παράδειγμα

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

Παράμετροι

Απόκριση

Παράδειγμα

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

Παράμετροι

Απάντηση

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

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