FastComments C++ SDK

Bu, FastComments için resmi C++ SDK'sıdır.

FastComments API'si için resmi C++ SDK

Depo

Gereksinimler

C++17 veya daha yeni
CMake 3.14 veya daha yeni
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (test için otomatik olarak indirilecek)

Kurulum

Bağımlılıkları Yükleme

sudo apt install libcpprest-dev libboost-all-dev

Kaynağından Derleme

mkdir build
cd build
cmake ..
make

Kurulum

sudo make install

Kütüphane İçeriği

Bu kütüphane, API ile çalışmayı kolaylaştıran oluşturulmuş API istemcisini ve SSO yardımcı araçlarını içerir.

API Client Library Docs

Genel ve Güvenli API'lar

API istemcisi için üç sınıf vardır: DefaultApi, PublicApi ve ModerationApi. DefaultApi, API anahtarınızı gerektiren yöntemleri içerir ve PublicApi, kimlik doğrulama olmadan doğrudan bir tarayıcı/mobil cihaz vb. üzerinden yapılabilen yöntemleri içerir. ModerationApi, canlı ve hızlı denetleme API'lerinin kapsamlı bir paketini sağlar. Her ModerationApi yöntemi bir sso parametresi alır ve SSO veya bir FastComments.com oturum çerezi aracılığıyla kimlik doğrulaması yapabilir.

Hızlı Başlangıç

Kimlik Doğrulamalı API'leri Kullanma (DefaultAPI)

Önemli:

Temel URL'yi ayarlamalısınız (cpp-restsdk üreticisi bunu OpenAPI spec'ten okumaz)
Kimlik doğrulamalı istekler yapmadan önce ApiClient üzerinde API anahtarınızı ayarlamalısınız. Bunu yapmazsanız, istekler 401 hatasıyla başarısız olur.

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

    // GEREKLİ: Temel URL'yi ayarlayın (bölgenizi seçin)
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));  // US
    // VEYA: config->setBaseUrl(utility::conversions::to_string_t("https://eu.fastcomments.com"));  // EU

    // GEREKLİ: API anahtarınızı ayarlayın
    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);

    // Şimdi kimlik doğrulamalı API çağrılarını yapın
    return 0;
}

Genel API'leri Kullanma (PublicAPI)

Genel uç noktalar kimlik doğrulama gerektirmez:

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

    // GEREKLİ: Temel URL'yi ayarlayın
    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);

    // Genel API çağrıları yapın
    return 0;
}

Moderatör API'lerini Kullanma (ModerationApi)

ModerationApi, moderatör panosunu güçlendirir. Her yöntem bir sso parametresi alır; böylece çağrı SSO ile kimlik doğrulamalı bir moderatör adına çalıştırılır (aşağıdaki SSO bölümünde token oluşturma hakkında bilgi bulabilirsiniz):

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

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

    // GEREKLİ: Temel URL'yi ayarlayın
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

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

    // Moderatörün SSO token'ını çağrıyı kimlik doğrulamak için geçin
    auto ssoToken = utility::conversions::to_string_t("YOUR_MODERATOR_SSO_TOKEN");

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

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

    return 0;
}

Ortak Sorunlar

"URI must contain a hostname" hatası: ApiClient oluşturulmadan önce config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) çağrısını yaptığınızdan emin olun. cpp-restsdk üreticisi sunucu URL'sini OpenAPI spec'ten otomatik olarak okumaz.
401 "missing-api-key" hatası: DefaultAPI örneği oluşturulmadan önce config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) çağrısını yaptığınızdan emin olun.
Yanlış API sınıfı: Sunucu tarafı kimlik doğrulamalı istekler için DefaultApi, istemci/halka açık istekler için PublicApi ve moderatör paneli istekleri (moderatör SSO token'ı ile kimlik doğrulamalı) için ModerationApi kullanın.

API Çağrısı Yapma: Senkron vs Asenkron

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

`.get()` ile Eşzamanlı Çağrılar

Use .get() to block the calling thread until the request completes and retrieve the result synchronously:

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

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

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

// Call .get() to block and get the result synchronously
auto response = api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    options
).get();  // Blocks until the HTTP request completes

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

`.then()` ile Asenkron Çağrılar

Use .then() for non-blocking asynchronous execution with callbacks:

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

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

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

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

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

Eşzamanlı ve Asenkron Arasında Seçim Yapmak

The choice depends on your runtime environment and application architecture:

.get() (Synchronous blocking)

Çağıran iş parçacığını HTTP isteği tamamlanana kadar engeller
Daha basit kod akışı, anlaşılması daha kolay
Ayrı çalışan iş parçacıkları, toplu işlem veya komut satırı araçları için uygundur
Uygun değildir olay döngüleri, GUI iş parçacıkları veya tek iş parçacıklı sunucular için

.then() (Asynchronous non-blocking)

Hemen döner, geri çağrı istek tamamlandığında çalışır
Çağıran iş parçacığını engellemez
Olay odaklı mimariler, GUI uygulamaları veya tek iş parçacıklı olay döngüleri için gereklidir
Birden fazla işlemi zincirleme imkanı sağlar
Daha karmaşık kontrol akışı

The SDK's test suite uses .get() exclusively, but this is appropriate for the test environment where blocking is acceptable.

Notlar

Yayın Kimlikleri

Bazı API çağrılarında broadcastId göndermeniz gerektiğini göreceksiniz. Olayları aldığınızda bu ID'yi geri alırsınız, böylece istemci üzerinde değişiklikleri iyimserce uygulamayı planlıyorsanız olayı yok saymanız gerektiğini bilirsiniz (muhtemelen en iyi deneyimi sunduğu için bunu yapmak istersiniz). Buraya bir UUID gönderin. ID, bir tarayıcı oturumunda iki kez oluşmayacak kadar benzersiz olmalıdır.

SSO (Tek Oturum Açma)

SSO örnekleri için aşağıya bakın.

SSO Kullanımı

Basit 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;
}

Güvenli 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 için Dokümantasyon

API Uç Noktaları İçin Dokümantasyon

Sınıf	Metod	HTTP isteği	Açıklama
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	Belgeleri, grupBy sağlanmışsa gruplayarak ve birden fazla işlem uygulayarak toplar. Farklı işlemler (ör. toplam, benzersizSayım, ortalama, vb.) desteklenir.
DefaultApi	aggregateQuestionResults	GET /api/v1/question-results-aggregation
DefaultApi	blockUserFromComment	POST /api/v1/comments/{id}/block
DefaultApi	bulkAggregateQuestionResults	POST /api/v1/question-results-aggregation/bulk
DefaultApi	changeTicketState	PATCH /api/v1/tickets/{id}/state
DefaultApi	combineCommentsWithQuestionResults	GET /api/v1/question-results-aggregation/combine/comments
DefaultApi	createEmailTemplate	POST /api/v1/email-templates
DefaultApi	createFeedPost	POST /api/v1/feed-posts
DefaultApi	createModerator	POST /api/v1/moderators
DefaultApi	createQuestionConfig	POST /api/v1/question-configs
DefaultApi	createQuestionResult	POST /api/v1/question-results
DefaultApi	createSubscription	POST /api/v1/subscriptions
DefaultApi	createTenant	POST /api/v1/tenants
DefaultApi	createTenantPackage	POST /api/v1/tenant-packages
DefaultApi	createTenantUser	POST /api/v1/tenant-users
DefaultApi	createTicket	POST /api/v1/tickets
DefaultApi	createUserBadge	POST /api/v1/user-badges
DefaultApi	createVote	POST /api/v1/votes
DefaultApi	deleteComment	DELETE /api/v1/comments/{id}
DefaultApi	deleteDomainConfig	DELETE /api/v1/domain-configs/{domain}
DefaultApi	deleteEmailTemplate	DELETE /api/v1/email-templates/{id}
DefaultApi	deleteEmailTemplateRenderError	DELETE /api/v1/email-templates/{id}/render-errors/{errorId}
DefaultApi	deleteHashTag	DELETE /api/v1/hash-tags/{tag}
DefaultApi	deleteModerator	DELETE /api/v1/moderators/{id}
DefaultApi	deleteNotificationCount	DELETE /api/v1/notification-count/{id}
DefaultApi	deletePage	DELETE /api/v1/pages/{id}
DefaultApi	deletePendingWebhookEvent	DELETE /api/v1/pending-webhook-events/{id}
DefaultApi	deleteQuestionConfig	DELETE /api/v1/question-configs/{id}
DefaultApi	deleteQuestionResult	DELETE /api/v1/question-results/{id}
DefaultApi	deleteSSOUser	DELETE /api/v1/sso-users/{id}
DefaultApi	deleteSubscription	DELETE /api/v1/subscriptions/{id}
DefaultApi	deleteTenant	DELETE /api/v1/tenants/{id}
DefaultApi	deleteTenantPackage	DELETE /api/v1/tenant-packages/{id}
DefaultApi	deleteTenantUser	DELETE /api/v1/tenant-users/{id}
DefaultApi	deleteUserBadge	DELETE /api/v1/user-badges/{id}
DefaultApi	deleteVote	DELETE /api/v1/votes/{id}
DefaultApi	flagComment	POST /api/v1/comments/{id}/flag
DefaultApi	getAuditLogs	GET /api/v1/audit-logs
DefaultApi	getCachedNotificationCount	GET /api/v1/notification-count/{id}
DefaultApi	getComment	GET /api/v1/comments/{id}
DefaultApi	getComments	GET /api/v1/comments
DefaultApi	getDomainConfig	GET /api/v1/domain-configs/{domain}
DefaultApi	getDomainConfigs	GET /api/v1/domain-configs
DefaultApi	getEmailTemplate	GET /api/v1/email-templates/{id}
DefaultApi	getEmailTemplateDefinitions	GET /api/v1/email-templates/definitions
DefaultApi	getEmailTemplateRenderErrors	GET /api/v1/email-templates/{id}/render-errors
DefaultApi	getEmailTemplates	GET /api/v1/email-templates
DefaultApi	getFeedPosts	GET /api/v1/feed-posts	req tenantId afterId
DefaultApi	getHashTags	GET /api/v1/hash-tags
DefaultApi	getModerator	GET /api/v1/moderators/{id}
DefaultApi	getModerators	GET /api/v1/moderators
DefaultApi	getNotificationCount	GET /api/v1/notifications/count
DefaultApi	getNotifications	GET /api/v1/notifications
DefaultApi	getPageByURLId	GET /api/v1/pages/by-url-id
DefaultApi	getPages	GET /api/v1/pages
DefaultApi	getPendingWebhookEventCount	GET /api/v1/pending-webhook-events/count
DefaultApi	getPendingWebhookEvents	GET /api/v1/pending-webhook-events
DefaultApi	getQuestionConfig	GET /api/v1/question-configs/{id}
DefaultApi	getQuestionConfigs	GET /api/v1/question-configs
DefaultApi	getQuestionResult	GET /api/v1/question-results/{id}
DefaultApi	getQuestionResults	GET /api/v1/question-results
DefaultApi	getSSOUserByEmail	GET /api/v1/sso-users/by-email/{email}
DefaultApi	getSSOUserById	GET /api/v1/sso-users/by-id/{id}
DefaultApi	getSSOUsers	GET /api/v1/sso-users
DefaultApi	getSubscriptions	GET /api/v1/subscriptions
DefaultApi	getTenant	GET /api/v1/tenants/{id}
DefaultApi	getTenantDailyUsages	GET /api/v1/tenant-daily-usage
DefaultApi	getTenantPackage	GET /api/v1/tenant-packages/{id}
DefaultApi	getTenantPackages	GET /api/v1/tenant-packages
DefaultApi	getTenantUser	GET /api/v1/tenant-users/{id}
DefaultApi	getTenantUsers	GET /api/v1/tenant-users
DefaultApi	getTenants	GET /api/v1/tenants
DefaultApi	getTicket	GET /api/v1/tickets/{id}
DefaultApi	getTickets	GET /api/v1/tickets
DefaultApi	getUser	GET /api/v1/users/{id}
DefaultApi	getUserBadge	GET /api/v1/user-badges/{id}
DefaultApi	getUserBadgeProgressById	GET /api/v1/user-badge-progress/{id}
DefaultApi	getUserBadgeProgressByUserId	GET /api/v1/user-badge-progress/user/{userId}
DefaultApi	getUserBadgeProgressList	GET /api/v1/user-badge-progress
DefaultApi	getUserBadges	GET /api/v1/user-badges
DefaultApi	getVotes	GET /api/v1/votes
DefaultApi	getVotesForUser	GET /api/v1/votes/for-user
DefaultApi	patchDomainConfig	PATCH /api/v1/domain-configs/{domainToUpdate}
DefaultApi	patchHashTag	PATCH /api/v1/hash-tags/{tag}
DefaultApi	patchPage	PATCH /api/v1/pages/{id}
DefaultApi	patchSSOUser	PATCH /api/v1/sso-users/{id}
DefaultApi	putDomainConfig	PUT /api/v1/domain-configs/{domainToUpdate}
DefaultApi	putSSOUser	PUT /api/v1/sso-users/{id}
DefaultApi	renderEmailTemplate	POST /api/v1/email-templates/render
DefaultApi	replaceTenantPackage	PUT /api/v1/tenant-packages/{id}
DefaultApi	replaceTenantUser	PUT /api/v1/tenant-users/{id}
DefaultApi	saveComment	POST /api/v1/comments
DefaultApi	saveCommentsBulk	POST /api/v1/comments/bulk
DefaultApi	sendInvite	POST /api/v1/moderators/{id}/send-invite
DefaultApi	sendLoginLink	POST /api/v1/tenant-users/{id}/send-login-link
DefaultApi	unBlockUserFromComment	POST /api/v1/comments/{id}/un-block
DefaultApi	unFlagComment	POST /api/v1/comments/{id}/un-flag
DefaultApi	updateComment	PATCH /api/v1/comments/{id}
DefaultApi	updateEmailTemplate	PATCH /api/v1/email-templates/{id}
DefaultApi	updateFeedPost	PATCH /api/v1/feed-posts/{id}
DefaultApi	updateModerator	PATCH /api/v1/moderators/{id}
DefaultApi	updateNotification	PATCH /api/v1/notifications/{id}
DefaultApi	updateQuestionConfig	PATCH /api/v1/question-configs/{id}
DefaultApi	updateQuestionResult	PATCH /api/v1/question-results/{id}
DefaultApi	updateSubscription	PATCH /api/v1/subscriptions/{id}
DefaultApi	updateTenant	PATCH /api/v1/tenants/{id}
DefaultApi	updateTenantPackage	PATCH /api/v1/tenant-packages/{id}
DefaultApi	updateTenantUser	PATCH /api/v1/tenant-users/{id}
DefaultApi	updateUserBadge	PUT /api/v1/user-badges/{id}
ModerationApi	deleteModerationVote	DELETE /auth/my-account/moderate-comments/mod_api/vote/{commentId}/{voteId}
ModerationApi	getApiComments	GET /auth/my-account/moderate-comments/mod_api/api/comments
ModerationApi	getApiExportStatus	GET /auth/my-account/moderate-comments/mod_api/api/export/status
ModerationApi	getApiIds	GET /auth/my-account/moderate-comments/mod_api/api/ids
ModerationApi	getBanUsersFromComment	GET /auth/my-account/moderate-comments/mod_api/ban-users/from-comment/{commentId}
ModerationApi	getCommentBanStatus	GET /auth/my-account/moderate-comments/mod_api/get-comment-ban-status/{commentId}
ModerationApi	getCommentChildren	GET /auth/my-account/moderate-comments/mod_api/comment-children/{commentId}
ModerationApi	getCount	GET /auth/my-account/moderate-comments/mod_api/count
ModerationApi	getCounts	GET /auth/my-account/moderate-comments/banned-users/mod_api/counts
ModerationApi	getLogs	GET /auth/my-account/moderate-comments/mod_api/logs/{commentId}
ModerationApi	getManualBadges	GET /auth/my-account/moderate-comments/mod_api/get-manual-badges
ModerationApi	getManualBadgesForUser	GET /auth/my-account/moderate-comments/mod_api/get-manual-badges-for-user
ModerationApi	getModerationComment	GET /auth/my-account/moderate-comments/mod_api/comment/{commentId}
ModerationApi	getModerationCommentText	GET /auth/my-account/moderate-comments/mod_api/get-comment-text/{commentId}
ModerationApi	getPreBanSummary	GET /auth/my-account/moderate-comments/mod_api/pre-ban-summary/{commentId}
ModerationApi	getSearchCommentsSummary	GET /auth/my-account/moderate-comments/mod_api/search/comments/summary
ModerationApi	getSearchPages	GET /auth/my-account/moderate-comments/mod_api/search/pages
ModerationApi	getSearchSites	GET /auth/my-account/moderate-comments/mod_api/search/sites
ModerationApi	getSearchSuggest	GET /auth/my-account/moderate-comments/mod_api/search/suggest
ModerationApi	getSearchUsers	GET /auth/my-account/moderate-comments/mod_api/search/users
ModerationApi	getTrustFactor	GET /auth/my-account/moderate-comments/mod_api/get-trust-factor
ModerationApi	getUserBanPreference	GET /auth/my-account/moderate-comments/mod_api/user-ban-preference
ModerationApi	getUserInternalProfile	GET /auth/my-account/moderate-comments/mod_api/get-user-internal-profile
ModerationApi	postAdjustCommentVotes	POST /auth/my-account/moderate-comments/mod_api/adjust-comment-votes/{commentId}
ModerationApi	postApiExport	POST /auth/my-account/moderate-comments/mod_api/api/export
ModerationApi	postBanUserFromComment	POST /auth/my-account/moderate-comments/mod_api/ban-user/from-comment/{commentId}
ModerationApi	postBanUserUndo	POST /auth/my-account/moderate-comments/mod_api/ban-user/undo
ModerationApi	postBulkPreBanSummary	POST /auth/my-account/moderate-comments/mod_api/bulk-pre-ban-summary
ModerationApi	postCommentsByIds	POST /auth/my-account/moderate-comments/mod_api/comments-by-ids
ModerationApi	postFlagComment	POST /auth/my-account/moderate-comments/mod_api/flag-comment/{commentId}
ModerationApi	postRemoveComment	POST /auth/my-account/moderate-comments/mod_api/remove-comment/{commentId}
ModerationApi	postRestoreDeletedComment	POST /auth/my-account/moderate-comments/mod_api/restore-deleted-comment/{commentId}
ModerationApi	postSetCommentApprovalStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-approval-status/{commentId}
ModerationApi	postSetCommentReviewStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-review-status/{commentId}
ModerationApi	postSetCommentSpamStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-spam-status/{commentId}
ModerationApi	postSetCommentText	POST /auth/my-account/moderate-comments/mod_api/set-comment-text/{commentId}
ModerationApi	postUnFlagComment	POST /auth/my-account/moderate-comments/mod_api/un-flag-comment/{commentId}
ModerationApi	postVote	POST /auth/my-account/moderate-comments/mod_api/vote/{commentId}
ModerationApi	putAwardBadge	PUT /auth/my-account/moderate-comments/mod_api/award-badge
ModerationApi	putCloseThread	PUT /auth/my-account/moderate-comments/mod_api/close-thread
ModerationApi	putRemoveBadge	PUT /auth/my-account/moderate-comments/mod_api/remove-badge
ModerationApi	putReopenThread	PUT /auth/my-account/moderate-comments/mod_api/reopen-thread
ModerationApi	setTrustFactor	PUT /auth/my-account/moderate-comments/mod_api/set-trust-factor
PublicApi	blockFromCommentPublic	POST /block-from-comment/{commentId}
PublicApi	checkedCommentsForBlocked	GET /check-blocked-comments
PublicApi	createCommentPublic	POST /comments/{tenantId}
PublicApi	createFeedPostPublic	POST /feed-posts/{tenantId}
PublicApi	createV1PageReact	POST /page-reacts/v1/likes/{tenantId}
PublicApi	createV2PageReact	POST /page-reacts/v2/{tenantId}
PublicApi	deleteCommentPublic	DELETE /comments/{tenantId}/{commentId}
PublicApi	deleteCommentVote	DELETE /comments/{tenantId}/{commentId}/vote/{voteId}
PublicApi	deleteFeedPostPublic	DELETE /feed-posts/{tenantId}/{postId}
PublicApi	deleteV1PageReact	DELETE /page-reacts/v1/likes/{tenantId}
PublicApi	deleteV2PageReact	DELETE /page-reacts/v2/{tenantId}
PublicApi	flagCommentPublic	POST /flag-comment/{commentId}
PublicApi	getCommentText	GET /comments/{tenantId}/{commentId}/text
PublicApi	getCommentVoteUserNames	GET /comments/{tenantId}/{commentId}/votes
PublicApi	getCommentsForUser	GET /comments-for-user
PublicApi	getCommentsPublic	GET /comments/{tenantId}	req tenantId urlId
PublicApi	getEventLog	GET /event-log/{tenantId}	req tenantId urlId userIdWS
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	req tenantId afterId
PublicApi	getFeedPostsStats	GET /feed-posts/{tenantId}/stats
PublicApi	getGifLarge	GET /gifs/get-large/{tenantId}
PublicApi	getGifsSearch	GET /gifs/search/{tenantId}
PublicApi	getGifsTrending	GET /gifs/trending/{tenantId}
PublicApi	getGlobalEventLog	GET /event-log/global/{tenantId}	req tenantId urlId userIdWS
PublicApi	getOfflineUsers	GET /pages/{tenantId}/users/offline	Sayfadaki daha önce yorum yapmış ancak şu anda çevrim dışı olan yorumcular. displayName göre sıralanır. /users/online sorgusunu tüketince "Members" bölümü oluşturmak için bunu kullanın. commenterName üzerine cursor sayfalama: sunucu, {tenantId, urlId, commenterName} kısmı indeksini afterName'den $gt ile ileri yürütür, $skip maliyeti yok.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	Şu anda bir sayfayı izleyen çevrimiçi izleyiciler: websoket oturumu sayfaya şu anda abone olan kişiler. anonCount + totalCount (odadaki tüm aboneler, içinde sıralamadığımız anonim izleyiciler dahil) döner.
PublicApi	getPagesPublic	GET /pages/{tenantId}	Bir tenant için sayfaları listeler. FChat masaüstü istemcisi tarafından oda listesini doldurmak için kullanılır. Her sayfanın çözümlenen özel yapılandırmasında `enableFChat` true olmalıdır. SSO gerektiren sayfalar, istek yapan kullanıcının grup erişimine göre filtrelenir.
PublicApi	getUserNotificationCount	GET /user-notifications/get-count
PublicApi	updateUserNotificationCommentSubscriptionStatus	POST /user-notifications/{notificationId}/mark-opted/{optedInOrOut}	Belirli bir yorum için bildirimleri etkinleştirir veya devre dışı bırakır.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Bir sayfa için bildirimleri etkinleştirir veya devre dışı bırakır. Kullanıcılar bir sayfaya abone olduğunda, yeni kök yorumlar için bildirimler oluşturulur ve ayrıca
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Bir resmi yükler ve yeniden boyutlandırır.
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Modeller İçin Dokümantasyon

Topla

Aggregates documents by grouping them (if groupBy is provided) and applying multiple operations.
Different operations (e.g. sum, countDistinct, avg, etc.) are supported.

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
aggregationRequest	AggregationRequest	Evet
options	const AggregateOptions&	Evet

Yanıt

Döndürür: AggregateResponse

Örnek

aggregate Örneği

Copy

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

Denetim Kayıtlarını Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
options	const GetAuditLogsOptions&	Evet

Yanıt

Döndürür: GetAuditLogsResponse

Örnek

getAuditLogs Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
GetAuditLogsOptions options;
options.startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-01T00:00:00Z"), utility::datetime::RFC_1123));
options.endDate   = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-31T23:59:59Z"), utility::datetime::RFC_1123));
options.limit     = boost::optional<int>(100);
api->getAuditLogs(tenantId, options).then([](pplx::task<std::shared_ptr<GetAuditLogsResponse>> t) {
    try {
        auto response = t.get();
        // yanıtı kullan
    } catch (const std::exception& e) {
        // hatayı işle
    }
});

Çıkış Yap (Genel)

Yanıt

Döndürür: APIEmptyResponse

Örnek

logoutPublic Örneği

Copy

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

Yorumdan Engelle (Genel)

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
commentId	string	Evet
publicBlockFromCommentParams	PublicBlockFromCommentParams	Evet
sso	string	Hayır

Yanıt

Döndürür: BlockSuccess

Örnek

blockFromCommentPublic Örnek

Copy

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

Yorumdaki Engeli Kaldır (Genel)

Parametreler

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
publicBlockFromCommentParams	PublicBlockFromCommentParams	Yes
sso	string	No

Yanıt

Döndürür: UnblockSuccess

Örnek

unBlockCommentPublic Örneği

Copy

auto blockParams = PublicBlockFromCommentParams();  
blockParams.reason = U("spam");  
api->unBlockCommentPublic(  
    U("my-tenant-123"),  
    U("comment-789"),  
    blockParams,  
    boost::optional<utility::string_t>(U("sso-token-abc"))  
).then([](std::shared_ptr<UnblockSuccess> result){ });

Engellenen Yorumları Kontrol Et

Parametreler

İsim	Tür	Gerekli
tenantId	string	Yes
commentIds	string	Yes
sso	string	No

Yanıt

Döndürür: CheckBlockedCommentsResponse

Örnek

checkedCommentsForBlocked Örneği

Copy

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

Kullanıcıyı Yorumdan Engelle

Parametreler

Ad	Tür	Zorunlu
tenantId	string	Evet
id	string	Evet
blockFromCommentParams	BlockFromCommentParams	Evet
options	const BlockUserFromCommentOptions&	Evet

Yanıt

Döndürür: BlockSuccess

Örnek

blockUserFromComment Örneği

Copy

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

Yorum Oluştur (Genel)

Parametreler

İsim	Tür	Gerekli
tenantId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
commentData	CommentData	Yes
options	const CreateCommentPublicOptions&	Yes

Yanıt

Döndürür: SaveCommentsResponseWithPresence

Örnek

createCommentPublic Örneği

Copy

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

Yorumu Sil

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
id	string	Evet
options	const DeleteCommentOptions&	Evet

Yanıt

Geri döner: DeleteCommentResult

Örnek

deleteComment Örneği

Copy

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

Yorumu Sil (Genel)

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
options	const DeleteCommentPublicOptions&	Yes

Yanıt

Döndürür: PublicAPIDeleteCommentResponse

Örnek

deleteCommentPublic Örneği

Copy

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

Yorum Oylamasını Sil

Parametreler

İsim	Tür	Gerekli
tenantId	string	Yes
commentId	string	Yes
voteId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
options	const DeleteCommentVoteOptions&	Yes

Yanıt

Döndürür: VoteDeleteResponse

Örnek

deleteCommentVote Örneği

Copy

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

Yorumu İşaretle

Parametreler

Ad	Tip	Gerekli
tenantId	string	Evet
id	string	Evet
options	const FlagCommentOptions&	Evet

Yanıt

Döndürür: FlagCommentResponse

Örnek

flagComment Örneği

Copy

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

Yorumu Al

Parametreler

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Yanıt

Döndürür: APIGetCommentResponse

Örnek

getComment Örneği

Copy

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

Yorumları Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
options	const GetCommentsOptions&	Evet

Yanıt

Returns: APIGetCommentsResponse

Örnek

getComments Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
GetCommentsOptions options;
options.page = 1;
options.limit = 50;
options.sort = U("newest");
options.authorEmail = boost::optional<utility::string_t>(U("user@example.com"));
api->getComments(tenantId, options).then([](pplx::task<std::shared_ptr<APIGetCommentsResponse>> task) {
    try {
        auto response = task.get();
        // yanıtı gerektiği gibi kullan
    } catch (const std::exception& e) {
        // hatayı ele al
    }
});

Yorumları Al (Genel)

istek tenantId urlId

Parametreler

Name	Type	Required
tenantId	string	Evet
urlId	string	Evet
options	const GetCommentsPublicOptions&	Evet

Yanıt

Döndürür: GetCommentsResponseWithPresence_PublicComment_

Örnek

getCommentsPublic Örneği

Copy

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

Yorum Metnini Al

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
commentId	string	Yes
options	const GetCommentTextOptions&	Yes

Yanıt

Döndürür: PublicAPIGetCommentTextResponse

Örnek

getCommentText Örneği

Copy

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

Yorum Oy Veren Kullanıcı Adlarını Al

Parametreler

Name	Type	Required
tenantId	string	Evet
commentId	string	Evet
dir	int32_t	Evet
sso	string	Hayır

Yanıt

Döndürür: GetCommentVoteUserNamesSuccessResponse

Örnek

getCommentVoteUserNames Örneği

Copy

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

Yorumu Kilitle

Parametreler

Ad	Tip	Gerekli
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Yanıt

Döner: APIEmptyResponse

Örnek

lockComment Örneği

Copy

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

Yorumu Sabitle

Parametreler

Name	Type	Required
tenantId	string	Evet
commentId	string	Evet
broadcastId	string	Evet
sso	string	Hayır

Yanıt

Döndürür: ChangeCommentPinStatusResponse

Örnek

pinComment Örneği

Copy

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

Yorumu Kaydet

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
createCommentParams	CreateCommentParams	Evet
options	const SaveCommentOptions&	Evet

Yanıt

Döndürür: APISaveCommentResponse

Örnek

saveComment Örneği

Copy

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

Yorum Metnini Ayarla

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
commentId	string	Evet
broadcastId	string	Evet
commentTextUpdateRequest	CommentTextUpdateRequest	Evet
options	const SetCommentTextOptions&	Evet

Yanıt

Döndürür: PublicAPISetCommentTextResponse

Örnek

setCommentText Örneği

Copy

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

Kullanıcının Yorum Engelini Kaldır

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
id	string	Yes
unBlockFromCommentParams	UnBlockFromCommentParams	Yes
options	const UnBlockUserFromCommentOptions&	Yes

Yanıt

Döndürür: UnblockSuccess

Örnek

unBlockUserFromComment Örneği

Copy

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

Yorum İşaretini Kaldır

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
id	string	Yes
options	const UnFlagCommentOptions&	Yes

Yanıt

Dönüş: FlagCommentResponse

Örnek

unFlagComment Örneği

Copy

auto options = UnFlagCommentOptions{};
options.reason = boost::optional<utility::string_t>(U("Resolved by moderator"));
api->unFlagComment(U("my-tenant-123"), U("comment-456"), options)
    .then([](std::shared_ptr<FlagCommentResponse> response) {
        if (response) {
            auto status = response->status;
            // gerektiğinde durumu işleyin
        }
    })
    .then([](pplx::task<void> previous) {
        try {
            previous.get();
        } catch (const std::exception& e) {
            // hatayı işleyin
        }
    });

Yorum Kilidini Aç

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
commentId	string	Evet
broadcastId	string	Evet
sso	string	Hayır

Yanıt

Döndürür: APIEmptyResponse

Örnek

unLockComment Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("cmt-456789");
auto broadcastId = utility::conversions::to_string_t("broadcast-001");
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("john.doe@example.com");
api->unLockComment(tenantId, commentId, broadcastId, sso).then([](pplx::task<std::shared_ptr<APIEmptyResponse>> task) {
    try {
        auto response = task.get();
    } catch (const std::exception&) {
    }
});

Yorum Sabitlemeyi Kaldır

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
commentId	string	Evet
broadcastId	string	Evet
sso	string	Hayır

Yanıt

Döndürür: ChangeCommentPinStatusResponse

Örnek

unPinComment Örneği

Copy

auto task = api->unPinComment(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("cmt-456789"),
    utility::conversions::to_string_t("broadcast-001"),
    boost::optional<utility::string_t>(utility::conversions::to_string_t("user@example.com"))
);
task.then([](std::shared_ptr<ChangeCommentPinStatusResponse> resp){
    auto result = std::make_shared<ChangeCommentPinStatusResponse>(*resp);
});

Yorumu Güncelle

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
id	string	Yes
updatableCommentParams	UpdatableCommentParams	Yes
options	const UpdateCommentOptions&	Yes

Yanıt

Döndürür: APIEmptyResponse

Örnek

updateComment Örneği

Copy

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

Yoruma Oy Ver

Parametreler

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
voteBodyParams	VoteBodyParams	Yes
options	const VoteCommentOptions&	Yes

Yanıt

Döndürür: VoteResponse

Örnek

voteComment Örneği

Copy

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

Kullanıcı İçin Yorumları Al

Parametreler

Ad	Tür	Gerekli	Açıklama
options	const GetCommentsForUserOptions&	Evet

Yanıt

Returns: GetCommentsForUserResponse

Örnek

getCommentsForUser Örnek

Copy

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

Alan Yapılandırması Ekle

Parametreler

İsim	Tür	Gerekli	Açıklama
tenantId	string	Evet
addDomainConfigParams	AddDomainConfigParams	Evet

Yanıt

Döndürür: AddDomainConfigResponse

Örnek

addDomainConfig Örneği

Copy

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

Alan Yapılandırmasını Sil

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
domain	string	Yes

Yanıt

Döndürür: DeleteDomainConfigResponse

Örnek

deleteDomainConfig Örneği

Copy

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

Alan Yapılandırmasını Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
domain	string	Evet

Yanıt

Döndürür: GetDomainConfigResponse

Örnek

getDomainConfig Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domain = U("myblog.example.com");
api->getDomainConfig(tenantId, domain)
    .then([](std::shared_ptr<GetDomainConfigResponse> response) {
        if (!response) return;
        boost::optional<bool> moderationEnabled = response->moderationEnabled;
        boost::optional<std::string> theme = response->theme;
        if (moderationEnabled && *moderationEnabled) {
            // etkin moderasyonu ele al
        }
        if (theme) {
            // tema değerini kullan
        }
    })
    .wait();

Alan Yapılandırmalarını Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes

Yanıt

Döndürür: GetDomainConfigsResponse

Örnek

getDomainConfigs Örneği

Copy

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

Alan Yapılandırmasını Kısmen Güncelle

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
domainToUpdate	string	Evet
patchDomainConfigParams	PatchDomainConfigParams	Evet

Yanıt

Returns: PatchDomainConfigResponse

Örnek

patchDomainConfig Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto domainToUpdate = utility::conversions::to_string_t("example.com");
PatchDomainConfigParams patchDomainConfigParams;
patchDomainConfigParams.enableComments = boost::optional<bool>(true);
patchDomainConfigParams.moderationLevel = boost::optional<int>(2);
patchDomainConfigParams.customHeader = boost::optional<utility::string_t>(utility::conversions::to_string_t("X-Custom-Header"));
api->patchDomainConfig(tenantId, domainToUpdate, patchDomainConfigParams)
    .then([](std::shared_ptr<PatchDomainConfigResponse> resp) {
        // başarı işleme
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* hata işleme */ }
    });

Alan Yapılandırmasını Değiştir

Parametreler

İsim	Tür	Gerekli
tenantId	string	Evet
domainToUpdate	string	Evet
updateDomainConfigParams	UpdateDomainConfigParams	Evet

Yanıt

Döndürür: PutDomainConfigResponse

Örnek

putDomainConfig Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domainToUpdate = U("example.com");
UpdateDomainConfigParams updateParams;
updateParams.enableComments = true;
updateParams.moderationLevel = boost::optional<int>(2);
updateParams.customCss = boost::optional<utility::string_t>(U(".fc-comment{color:red;}"));
api->putDomainConfig(tenantId, domainToUpdate, updateParams)
    .then([](std::shared_ptr<PutDomainConfigResponse> resp) {
    });

E-posta Şablonu Oluştur

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
createEmailTemplateBody	CreateEmailTemplateBody	Yes

Yanıt

Döndürür: CreateEmailTemplateResponse

Örnek

createEmailTemplate Örneği

Copy

auto body = std::make_shared<CreateEmailTemplateBody>();
body->subject = utility::string_t("Welcome Email");
body->htmlContent = utility::string_t("<h1>Welcome!</h1><p>Thanks for joining.</p>");
body->fromEmail = utility::string_t("no-reply@myapp.com");
body->replyTo = boost::optional<utility::string_t>(utility::string_t("support@myapp.com"));
body->cc = boost::none;
api->createEmailTemplate(utility::string_t("my-tenant-123"), *body)
    .then([](std::shared_ptr<CreateEmailTemplateResponse> resp) {
        std::cout << "Created template ID: " << resp->id << std::endl;
    });

E-posta Şablonunu Sil

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
id	string	Yes

Yanıt

Döndürür: APIEmptyResponse

Örnek

deleteEmailTemplate Örneği

Copy

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

E-posta Şablonu Render Hatasını Sil

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
id	string	Evet
errorId	string	Evet

Yanıt

Döndürür: APIEmptyResponse

Örnek

deleteEmailTemplateRenderError Örnek

Copy

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

E-posta Şablonunu Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
id	string	Evet

Yanıt

Döner: GetEmailTemplateResponse

Örnek

getEmailTemplate Örneği

Copy

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

E-posta Şablonu Tanımlarını Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes

Yanıt

Döndürür: GetEmailTemplateDefinitionsResponse

Örnek

getEmailTemplateDefinitions Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
api->getEmailTemplateDefinitions(tenantId).then([](pplx::task<std::shared_ptr<GetEmailTemplateDefinitionsResponse>> t) {
    try {
        auto resp = t.get();
        boost::optional<utility::string_t> tmplName = resp ? resp->templateName : boost::none;
        if (tmplName) {
            std::cout << *tmplName << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
});

E-posta Şablonu Render Hatalarını Al

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
id	string	Evet
skip	double	Hayır

Yanıt

Döndürür: GetEmailTemplateRenderErrorsResponse

Örnek

getEmailTemplateRenderErrors Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("email-template-789");
boost::optional<double> skip = 20.0;
api->getEmailTemplateRenderErrors(tenantId, id, skip)
    .then([](pplx::task<std::shared_ptr<GetEmailTemplateRenderErrorsResponse>> task) {
        try {
            auto response = task.get();
            // Yanıtı gerektiği gibi kullan
        } catch (const std::exception& ex) {
            // Hata yakala
        }
    });

E-posta Şablonlarını Al

Parameters

Name	Type	Required	Description
tenantId	string	Yes
skip	double	No

Response

Döndürür: GetEmailTemplatesResponse

Example

getEmailTemplates Örneği

Copy

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

E-posta Şablonunu Render Et

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
renderEmailTemplateBody	RenderEmailTemplateBody	Evet
locale	string	Hayır

Yanıt

Döndürür: RenderEmailTemplateResponse

Örnek

renderEmailTemplate Örneği

Copy

auto body = RenderEmailTemplateBody();
body.templateId = U("welcome-email");
body.recipientEmail = U("user@example.com");
boost::optional<utility::string_t> locale = U("en-US");
api->renderEmailTemplate(U("my-tenant-123"), body, locale)
    .then([](std::shared_ptr<RenderEmailTemplateResponse> resp) {
        std::cout << "Email template rendered successfully\n";
    });

E-posta Şablonunu Güncelle

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
id	string	Evet
updateEmailTemplateBody	UpdateEmailTemplateBody	Evet

Yanıt

Döndürür: APIEmptyResponse

Örnek

updateEmailTemplate Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email");
UpdateEmailTemplateBody body;
body.subject = U("Welcome to Our Platform");
body.content = U("<p>Hello \{{userName}}, welcome aboard!</p>");
body.isActive = boost::optional<bool>(true);
api->updateEmailTemplate(tenantId, templateId, body)
    .then([](std::shared_ptr<APIEmptyResponse> response) {
        // başarı işleme
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception &) { /* hata işleme */ }
    });

Olay Günlüğünü Al

req tenantId urlId userIdWS

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
urlId	string	Yes
userIdWS	string	Yes
startTime	int64_t	Yes
endTime	int64_t	No

Yanıt

Döndürür: GetEventLogResponse

Örnek

getEventLog Örneği

Copy

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

Global Olay Günlüğünü Al

req tenantId urlId userIdWS

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
urlId	string	Evet
userIdWS	string	Evet
startTime	int64_t	Evet
endTime	int64_t	Hayır

Yanıt

Döndürür: GetEventLogResponse

Örnek

getGlobalEventLog Örneği

Copy

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

Akış Gönderisi Oluştur

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
options	const CreateFeedPostOptions&	Yes

Yanıt

Döndürür: CreateFeedPostsResponse

Örnek

createFeedPost Örneği

Copy

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

Akış Gönderisi Oluştur (Genel)

Parameters

İsim	Tür	Gerekli
tenantId	string	Evet
createFeedPostParams	CreateFeedPostParams	Evet
options	const CreateFeedPostPublicOptions&	Evet

Response

Döndürür: CreateFeedPostResponse

Örnek

createFeedPostPublic Örneği

Copy

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

Akış Gönderisini Sil (Genel)

Parametreler

İsim	Tür	Gerekli
tenantId	string	Evet
postId	string	Evet
options	const DeleteFeedPostPublicOptions&	Evet

Yanıt

Döndürür: DeleteFeedPostPublicResponse

Örnek

deleteFeedPostPublic Örneği

Copy

auto opts = std::make_shared<DeleteFeedPostPublicOptions>();
opts->reason = boost::optional<utility::string_t>(U("Inappropriate content"));
api->deleteFeedPostPublic(U("my-tenant-123"), U("post-789"), *opts)
    .then([](std::shared_ptr<DeleteFeedPostPublicResponse> resp) {
        if (resp && resp->isSuccess()) {
            // başarı mantığı
        }
    });

Akış Gönderilerini Al

req tenantId afterId

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
options	const GetFeedPostsOptions&	Evet

Yanıt

Döndürür: GetFeedPostsResponse

Örnek

getFeedPosts Örneği

Copy

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

Akış Gönderilerini Al (Genel)

req tenantId afterId

Parametreler

Name	Type	Required	Description
tenantId	string	Evet
options	const GetFeedPostsPublicOptions&	Evet

Yanıt

Döndürür: PublicFeedPostsResponse

Örnek

getFeedPostsPublic Örneği

Copy

auto options = GetFeedPostsPublicOptions{};
options.limit = boost::optional<int>{20};
options.before = boost::optional<utility::string_t>{U("2023-01-01T00:00:00Z")};
api->getFeedPostsPublic(U("my-tenant-123"), options).then([](pplx::task<std::shared_ptr<PublicFeedPostsResponse>> task){
    try{
        auto response = task.get();
        auto processed = std::make_shared<PublicFeedPostsResponse>(*response);
        // Use processed as needed
    }catch(const std::exception&){
        // Handle error
    }
});

Akış Gönderileri İstatistiklerini Al

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
postIds	vector<string	Evet
sso	string	Hayır

Yanıt

Döndürür: FeedPostsStatsResponse

Örnek

getFeedPostsStats Örneği

Copy

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

Kullanıcı Tepkilerini Al (Genel)

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
options	const GetUserReactsPublicOptions&	Yes

Yanıt

Döndürür: UserReactsResponse

Örnek

getUserReactsPublic Örnek

Copy

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

Akış Gönderisine Tepki Ver (Genel)

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
postId	string	Yes
reactBodyParams	ReactBodyParams	Yes
options	const ReactFeedPostPublicOptions&	Yes

Yanıt

Returns: ReactFeedPostResponse

Örnek

reactFeedPostPublic Örneği

Copy

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

Akış Gönderisini Güncelle

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
id	string	Yes
feedPost	FeedPost	Yes

Yanıt

Döndürür: APIEmptyResponse

Örnek

updateFeedPost Örneği

Copy

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

Akış Gönderisini Güncelle (Genel)

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
postId	string	Yes
updateFeedPostParams	UpdateFeedPostParams	Yes
options	const UpdateFeedPostPublicOptions&	Yes

Yanıt

Döndürür: CreateFeedPostResponse

Örnek

updateFeedPostPublic Örneği

Copy

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

Yorumu İşaretle (Genel)

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
commentId	string	Yes
isFlagged	bool	Yes
sso	string	No

Yanıt

Döndürür: APIEmptyResponse

Örnek

flagCommentPublic Örneği

Copy

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

Büyük GIF Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
largeInternalURLSanitized	string	Yes

Yanıt

Döndürür: GifGetLargeResponse

Örnek

getGifLarge Örneği

Copy

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

GIF Arama Sonuçlarını Al

Parametreler

Name	Type	Required
tenantId	string	Yes
search	string	Yes
options	const GetGifsSearchOptions&	Yes

Yanıt

Döndürür: GetGifsSearchResponse

Örnek

getGifsSearch Örneği

Copy

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

Trend GIF'leri Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
options	const GetGifsTrendingOptions&	Yes

Yanıt

Döndürür: GetGifsTrendingResponse

Örnek

getGifsTrending Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
GetGifsTrendingOptions options;
options.limit = 10;
options.rating = boost::optional<utility::string_t>(U("G"));
api->getGifsTrending(tenantId, options).then([](std::shared_ptr<GetGifsTrendingResponse> response) {
    for (const auto& gif : response->gifs) {
        auto url = gif.url;
    }
});

Hashtag Ekle

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
createHashTagBody	CreateHashTagBody	Yes

Yanıt

Döndürür: CreateHashTagResponse

Örnek

addHashTag Örneği

Copy

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

Hashtag'leri Toplu Ekle

Parametreler

Name	Type	Required	Description
tenantId	string	Yes
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Yes

Yanıt

Döndürür: BulkCreateHashTagsResponse

Örnek

addHashTagsBulk Örnek

Copy

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

Hashtag'i Sil

Parametreler

Name	Type	Required
tenantId	string	Yes
tag	string	Yes
deleteHashTagRequestBody	DeleteHashTagRequestBody	Yes

Yanıt

Döner: APIEmptyResponse

Örnek

deleteHashTag Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-001");
auto tag = utility::conversions::to_string_t("news");
DeleteHashTagRequestBody requestBody;
requestBody.userId = utility::conversions::to_string_t("user-42");
requestBody.reason = boost::optional<utility::string_t>(utility::conversions::to_string_t("User request"));
api->deleteHashTag(tenantId, tag, requestBody)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
    });

Hashtag'leri Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
page	double	Hayır

Yanıt

Döndürür: GetHashTagsResponse

Örnek

getHashTags Örnek

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
boost::optional<double> page = 2.0;
api->getHashTags(tenantId, page).then([](pplx::task<std::shared_ptr<GetHashTagsResponse>> task) {
    try {
        auto resultPtr = task.get();
        auto response = std::make_shared<GetHashTagsResponse>(*resultPtr);
        // yanıtı kullan
    } catch (const std::exception&) {
        // hatayı ele al
    }
});

Hashtag'i Kısmen Güncelle

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
tag	string	Evet
updateHashTagBody	UpdateHashTagBody	Evet

Yanıt

Döndürür: UpdateHashTagResponse

Örnek

patchHashTag Örneği

Copy

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

Moderasyon Oylamasını Sil

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
commentId	string	Evet
voteId	string	Evet
options	const DeleteModerationVoteOptions&	Evet

Yanıt

Döndürür: VoteDeleteResponse

Örnek

deleteModerationVote Örneği

Copy

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

API Yorumlarını Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
options	const GetApiCommentsOptions&	Evet

Yanıt

Döndürür: ModerationAPIGetCommentsResponse

Örnek

getApiComments Örneği

Copy

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

API Dışa Aktarma Durumunu Al

Parametreler

İsim	Tür	Gerekli	Açıklama
tenantId	string	Evet
options	const GetApiExportStatusOptions&	Evet

Yanıt

Döndürür: ModerationExportStatusResponse

Örnek

getApiExportStatus Örneği

Copy

auto opts = GetApiExportStatusOptions{};
opts.exportId = boost::make_optional<utility::string_t>(U("export-456"));
api->getApiExportStatus(U("my-tenant-123"), opts)
    .then([](pplx::task<std::shared_ptr<ModerationExportStatusResponse>> t){
        try{
            auto status = t.get();
        }catch(const std::exception&){
        }
    });

API Kimliklerini Al

Parametreler

Ad	Tür	Zorunlu	Açıklama
tenantId	string	Evet
options	const GetApiIdsOptions&	Evet

Yanıt

Döndürür: ModerationAPIGetCommentIdsResponse

Örnek

getApiIds Örnek

Copy

utility::string_t tenantId = U("my-tenant-123");
GetApiIdsOptions options;
options.limit = boost::optional<int>(100);
options.cursor = boost::optional<utility::string_t>(U("next-page-token"));
api->getApiIds(tenantId, options).then([](pplx::task<std::shared_ptr<ModerationAPIGetCommentIdsResponse>> t){
    try{
        auto response = t.get();
        auto ids = response->commentIds;
    }catch(const std::exception&){
    }
});

Yorumdan Yasaklı Kullanıcıları Al

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Yanıt

Döndürür: GetBannedUsersFromCommentResponse

Örnek

getBanUsersFromComment Örnek

Copy

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

Yorum Yasak Durumunu Al

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
commentId	string	Evet
sso	string	Hayır

Yanıt

Döndürür: GetCommentBanStatusResponse

Örnek

getCommentBanStatus Örneği

Copy

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

Yorumun Alt Yorumlarını Al

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Yanıt

Returns: ModerationAPIChildCommentsResponse

Örnek

getCommentChildren Örneği

Copy

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

Sayımı Al

Parametreler

Ad	Tür	Zorunlu	Açıklama
tenantId	string	Yes
options	const GetCountOptions&	Yes

Yanıt

Döndürür: ModerationAPICountCommentsResponse

Örnek

getCount Örneği

Copy

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

Sayım Değerlerini Al

Parametreler

Name	Type	Required	Description
tenantId	string	Evet
sso	string	Hayır

Yanıt

Döndürür: GetBannedUsersCountResponse

Örnek

getCounts Örneği

Copy

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

Günlükleri Al

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
commentId	string	Evet
sso	string	Hayır

Yanıt

Döndürür: ModerationAPIGetLogsResponse

Örnek

getLogs Örneği

Copy

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

Manuel Rozetleri Al

Parameters

İsim	Tür	Gerekli	Açıklama
tenantId	string	Evet
sso	string	Hayır

Response

Döndürür: GetTenantManualBadgesResponse

Example

getManualBadges Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> sso = boost::make_optional(U("user@example.com"));
api->getManualBadges(tenantId, sso)
    .then([](pplx::task<std::shared_ptr<GetTenantManualBadgesResponse>> t) {
        try {
            auto response = t.get();
            // yanıtı işle, örn., response->badgeList
        } catch (const std::exception& ex) {
            // hatayı işle
        }
    });

Kullanıcı İçin Manuel Rozetleri Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
options	const GetManualBadgesForUserOptions&	Yes

Yanıt

Döndürür: GetUserManualBadgesResponse

Örnek

getManualBadgesForUser Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
GetManualBadgesForUserOptions options;
options.userEmail = boost::optional<utility::string_t>(U("user@example.com"));
options.includeInactive = boost::optional<bool>(true);
api->getManualBadgesForUser(tenantId, options).then([](pplx::task<std::shared_ptr<GetUserManualBadgesResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){
    }
});

Moderasyon Yorumu Al

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
commentId	string	Yes
options	const GetModerationCommentOptions&	Yes

Yanıt

Döndürür: ModerationAPICommentResponse

Örnek

getModerationComment Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-456");
GetModerationCommentOptions options;
options.includeDeleted = boost::optional<bool>(true);
options.locale = boost::optional<utility::string_t>(utility::conversions::to_string_t("en-US"));
api->getModerationComment(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<ModerationAPICommentResponse>> task) {
        try {
            auto response = task.get();
            // Process response as needed
        } catch (const std::exception& ex) {
            // Handle error
        }
    });

Moderasyon Yorum Metnini Al

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
commentId	string	Evet
sso	string	Hayır

Yanıt

Döndürür: GetCommentTextResponse

Örnek

getModerationCommentText Örneği

Copy

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

Ön Yasak Özetini Al

Parameters

Ad	Tür	Gerekli
tenantId	string	Evet
commentId	string	Evet
options	const GetPreBanSummaryOptions&	Evet

Response

Döndürür: PreBanSummary

Example

getPreBanSummary Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("cmt-456789");
GetPreBanSummaryOptions options;
options.locale = boost::optional<utility::string_t>{utility::conversions::to_string_t("en-US")};
api->getPreBanSummary(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<PreBanSummary>> t) {
        try {
            auto summary = t.get();
            // özeti işle
        } catch (const std::exception&) {
            // hatayı işle
        }
    });

Arama Yorumları Özetini Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
options	const GetSearchCommentsSummaryOptions&	Yes

Yanıt

Döndürür: ModerationCommentSearchResponse

Örnek

getSearchCommentsSummary Örneği

Copy

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

Arama Sayfalarını Al

Parametreler

Ad	Tür	Zorunlu	Açıklama
tenantId	string	Evet
options	const GetSearchPagesOptions&	Evet

Yanıt

Döndürür: ModerationPageSearchResponse

Örnek

getSearchPages Örneği

Copy

GetSearchPagesOptions options;
options.pageNumber = boost::optional<int>(1);
options.pageSize = boost::optional<int>(50);
options.searchTerm = boost::optional<utility::string_t>(U("spam"));
api->getSearchPages(U("my-tenant-123"), options)
    .then([](pplx::task<std::shared_ptr<ModerationPageSearchResponse>> task) {
        try {
            auto response = task.get();
            // yanıtı kullan
        } catch (const std::exception& e) {
            // hatayı ele al
        }
    });

Arama Sitelerini Al

Parametreler

İsim	Tür	Gerekli	Açıklama
tenantId	string	Evet
options	const GetSearchSitesOptions&	Evet

Yanıt

Döndürür: ModerationSiteSearchResponse

Örnek

getSearchSites Örneği

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
GetSearchSitesOptions options;
options.query = boost::make_optional(utility::string_t(U("example query")));
options.limit = boost::make_optional(25);
api->getSearchSites(tenantId, options)
   .then([](pplx::task<std::shared_ptr<ModerationSiteSearchResponse>> t) {
       try {
           auto response = t.get();
           auto respPtr = std::make_shared<ModerationSiteSearchResponse>(*response);
           for (const auto& site : respPtr->sites) {
               // işleme mantığı
           }
       } catch (const std::exception&) {
           // hata işleme
       }
   });

Arama Önerilerini Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
options	const GetSearchSuggestOptions&	Evet

Yanıt

Döndürür: ModerationSuggestResponse

Örnek

getSearchSuggest Örneği

Copy

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

Arama Kullanıcılarını Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
options	const GetSearchUsersOptions&	Evet

Yanıt

Döndürür: ModerationUserSearchResponse

Örnek

getSearchUsers Örneği

Copy

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

Güven Faktörünü Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
options	const GetTrustFactorOptions&	Evet

Yanıt

Döndürür: GetUserTrustFactorResponse

Örnek

getTrustFactor Örneği

Copy

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

Kullanıcı Yasak Tercihini Al

Parametreler

Ad	Tip	Gereklidir	Açıklama
tenantId	string	Evet
sso	string	Hayır

Response

Döndürür: APIModerateGetUserBanPreferencesResponse

Örnek

getUserBanPreference Örneği

Copy

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

Kullanıcı İç Profilini Al

Parametreler

İsim	Tür	Gerekli	Açıklama
tenantId	string	Evet
options	const GetUserInternalProfileOptions&	Evet

Yanıt

Döndürür: GetUserInternalProfileResponse

Örnek

getUserInternalProfile Örneği

Copy

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

Yorum Oylarını Ayarla

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
commentId	string	Evet
adjustCommentVotesParams	AdjustCommentVotesParams	Evet
options	const PostAdjustCommentVotesOptions&	Evet

Yanıt

Returns: AdjustVotesResponse

Örnek

postAdjustCommentVotes Örneği

Copy

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

API Dışa Aktarma Yap

Parametreler

Name	Type	Required	Description
tenantId	string	Yes
options	const PostApiExportOptions&	Yes

Yanıt

Döndürür: ModerationExportResponse

Örnek

postApiExport Örneği

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
PostApiExportOptions options;
options.format = utility::string_t(U("json"));
options.email = utility::string_t(U("reports@example.com"));
options.startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-01T00:00:00Z")));
options.endDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-31T23:59:59Z")));
api->postApiExport(tenantId, options)
    .then([](std::shared_ptr<ModerationExportResponse> response) {
        if (response) {
            // başarılı dışa aktarım yanıtını işle
        }
    })
    .wait();

Yoruma Kullanıcıyı Yasakla

Parametreler

İsim	Tür	Gerekli
tenantId	string	Yes
commentId	string	Yes
options	const PostBanUserFromCommentOptions&	Yes

Yanıt

Döndürür: BanUserFromCommentResult

Örnek

postBanUserFromComment Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("comment-456789");
PostBanUserFromCommentOptions options;
options.reason = boost::optional<utility::string_t>(U("spam"));
options.durationDays = boost::optional<int>(30);
api->postBanUserFromComment(tenantId, commentId, options)
    .then([](std::shared_ptr<BanUserFromCommentResult> result) {
        // sonuç işleme
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* hata işleme */ }
    });

Kullanıcı Yasaklamasını Geri Al

Parameters

Name	Type	Required
tenantId	string	Evet
banUserUndoParams	BanUserUndoParams	Evet
sso	string	Hayır

Response

Döndürür: APIEmptyResponse

Example

postBanUserUndo Örneği

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
BanUserUndoParams banParams;
banParams.userId = utility::string_t(U("user-567"));
banParams.reason = utility::string_t(U("reinstated"));
boost::optional<utility::string_t> sso = utility::string_t(U("sso-token-abc"));
api->postBanUserUndo(tenantId, banParams, sso).then([](std::shared_ptr<APIEmptyResponse> resp){
    // başarıyı işle
});

Toplu Ön Yasak Özeti Gönder

Parametreler

Name	Type	Required
tenantId	string	Yes
bulkPreBanParams	BulkPreBanParams	Yes
options	const PostBulkPreBanSummaryOptions&	Yes

Yanıt

Returns: BulkPreBanSummary

Örnek

postBulkPreBanSummary Örnek

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
BulkPreBanParams bulkPreBanParams;
bulkPreBanParams.emails = {
    utility::conversions::to_string_t("spam1@example.com"),
    utility::conversions::to_string_t("spam2@example.com")
};
bulkPreBanParams.reason = utility::conversions::to_string_t("spam");
PostBulkPreBanSummaryOptions options;
options.requestId = boost::optional<utility::string_t>(utility::conversions::to_string_t("req-456"));
api->postBulkPreBanSummary(tenantId, bulkPreBanParams, options)
    .then([](std::shared_ptr<BulkPreBanSummary> result) {
        (void)result;
    });

ID'lere Göre Yorumları Gönder

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
commentsByIdsParams	CommentsByIdsParams	Yes
sso	string	No

Yanıt

Döndürür: ModerationAPIChildCommentsResponse

Örnek

postCommentsByIds Örneği

Copy

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

Yorumu İşaretle (Gönder)

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
commentId	string	Yes
options	const PostFlagCommentOptions&	Yes

Yanıt

Döndürür: APIEmptyResponse

Örnek

postFlagComment Örneği

Copy

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

Yorumu Kaldır

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
commentId	string	Yes
options	const PostRemoveCommentOptions&	Yes

Yanıt

Döndürür: PostRemoveCommentApiResponse

Örnek

postRemoveComment Örneği

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto commentId = utility::string_t(U("cmt-456789"));
PostRemoveCommentOptions options;
options.permanent = boost::optional<bool>(true);
api->postRemoveComment(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<PostRemoveCommentApiResponse>> task) {
        try {
            auto response = task.get();
            // Yanıtı işle
        } catch (const std::exception& ex) {
            // Hata yakala
        }
    });

Silinmiş Yorumu Geri Yükle

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
commentId	string	Yes
options	const PostRestoreDeletedCommentOptions&	Yes

Yanıt

Döndürür: APIEmptyResponse

Örnek

postRestoreDeletedComment Örneği

Copy

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

Yorum Onay Durumunu Ayarla

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
commentId	string	Evet
options	const PostSetCommentApprovalStatusOptions&	Evet

Yanıt

Döndürür: SetCommentApprovedResponse

Örnek

postSetCommentApprovalStatus Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-abc123");
auto options = std::make_shared<PostSetCommentApprovalStatusOptions>();
options->approved = boost::optional<bool>(true);
options->reason = boost::optional<utility::string_t>(utility::conversions::to_string_t("Inappropriate content"));
api->postSetCommentApprovalStatus(tenantId, commentId, *options)
    .then([](pplx::task<std::shared_ptr<SetCommentApprovedResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception& ex) {
        }
    });

Yorum İnceleme Durumunu Ayarla

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
commentId	string	Evet
options	const PostSetCommentReviewStatusOptions&	Evet

Yanıt

Döndürür: APIEmptyResponse

Örnek

postSetCommentReviewStatus Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("cmt-456789");
PostSetCommentReviewStatusOptions opts;
opts.status = utility::conversions::to_string_t("approved");
opts.note = boost::optional<utility::string_t>(utility::conversions::to_string_t("Looks good"));
api->postSetCommentReviewStatus(tenantId, commentId, opts)
    .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> t){
        try{
            auto resp = t.get();
        }catch(const std::exception& e){
        }
    });

Yorum Spam Durumunu Ayarla

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
commentId	string	Yes
options	const PostSetCommentSpamStatusOptions&	Yes

Yanıt

Döndürür: APIEmptyResponse

Örnek

postSetCommentSpamStatus Örneği

Copy

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

Yorum Metnini Ayarla (Gönder)

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
commentId	string	Yes
setCommentTextParams	SetCommentTextParams	Yes
options	const PostSetCommentTextOptions&	Yes

Yanıt

Döndürür: SetCommentTextResponse

Örnek

postSetCommentText Örneği

Copy

auto tenantId = U("my-tenant-123");
auto commentId = U("comment-456");
SetCommentTextParams params;
params.text = U("Revised comment content");
PostSetCommentTextOptions options;
options.requestId = boost::optional<utility::string_t>(U("req-987"));
api->postSetCommentText(tenantId, commentId, params, options)
    .then([](std::shared_ptr<SetCommentTextResponse> resp) {
        auto updatedId = resp->commentId;
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

Yorum İşaretini Kaldır (Gönder)

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
commentId	string	Yes
options	const PostUnFlagCommentOptions&	Yes

Yanıt

Döndürür: APIEmptyResponse

Örnek

postUnFlagComment Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
PostUnFlagCommentOptions opts;
opts.notifyUser = boost::optional<bool>(true);
api->postUnFlagComment(tenantId, commentId, opts)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // işlem burada yapılabilir
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

Oy Gönder

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
commentId	string	Evet
options	const PostVoteOptions&	Evet

Yanıt

Döndürür: VoteResponse

Örnek

postVote Örneği

Copy

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

Rozet Ver

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
badgeId	string	Evet
options	const PutAwardBadgeOptions&	Evet

Yanıt

Döndürür: AwardUserBadgeResponse

Örnek

putAwardBadge Örneği

Copy

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

Konuyu Kapat

Parametreler

İsim	Tür	Gerekli
tenantId	string	Evet
urlId	string	Evet
sso	string	Hayır

Yanıt

Döndürür: APIEmptyResponse

Örnek

putCloseThread Örneği

Copy

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

Rozeti Kaldır

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
badgeId	string	Evet
options	const PutRemoveBadgeOptions&	Evet

Yanıt

Döndürür: RemoveUserBadgeResponse

Örnek

putRemoveBadge Örneği

Copy

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

Konuyu Yeniden Aç

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
urlId	string	Evet
sso	string	Hayır

Yanıt

Döndürür: APIEmptyResponse

Örnek

putReopenThread Örneği

Copy

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

Güven Faktörünü Ayarla

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
options	const SetTrustFactorOptions&	Evet

Yanıt

Döndürür: SetUserTrustFactorResponse

Örnek

setTrustFactor Örneği

Copy

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

Moderatör Oluştur

Parametreler

İsim	Tip	Gerekli	Açıklama
tenantId	string	Yes
createModeratorBody	CreateModeratorBody	Yes

Yanıt

Döndürür: CreateModeratorResponse

Örnek

createModerator Örneği

Copy

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

Moderatörü Sil

Parametreler

İsim	Tür	Gerekli
tenantId	string	Yes
id	string	Yes
sendEmail	string	No

Yanıt

Döndürür: APIEmptyResponse

Örnek

deleteModerator Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto moderatorId = utility::conversions::to_string_t("mod-456");
boost::optional<utility::string_t> sendEmail = utility::conversions::to_string_t("admin@example.com");
api->deleteModerator(tenantId, moderatorId, sendEmail)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // başarılı yanıtı işle
    });

Moderatörü Al

Parametreler

Ad	Tip	Gerekli	Açıklama
tenantId	string	Yes
id	string	Yes

Yanıt

Döndürür: GetModeratorResponse

Örnek

getModerator Örneği

Copy

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

Moderatörleri Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
skip	double	Hayır

Yanıt

Returns: GetModeratorsResponse

Örnek

getModerators Örneği

Copy

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

Davet Gönder

Parametreler

Name	Type	Required
tenantId	string	Yes
id	string	Yes
fromName	string	Yes

Yanıt

Döndürür: APIEmptyResponse

Örnek

sendInvite Örneği

Copy

boost::optional<utility::string_t> cc = utility::conversions::to_string_t("cc@example.com");
api->sendInvite(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("invitee@example.com"),
    utility::conversions::to_string_t("John Doe")
).then([](std::shared_ptr<APIEmptyResponse> resp) {
    // başarılı daveti işle
});

Moderatörü Güncelle

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateModeratorBody	UpdateModeratorBody	Yes

Response

Döndürür: APIEmptyResponse

Example

updateModerator Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto moderatorId = utility::conversions::to_string_t("mod-789");
UpdateModeratorBody body;
body.email = utility::conversions::to_string_t("moderator@example.com");
body.isActive = true;
body.notes = boost::optional<utility::string_t>(utility::conversions::to_string_t("Senior moderator"));
api->updateModerator(tenantId, moderatorId, body)
    .then([](std::shared_ptr<APIEmptyResponse>) {})
    .then([](pplx::task<void> t) { try { t.get(); } catch (const std::exception&) {} });

Bildirim Sayısını Sil

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
id	string	Yes

Yanıt

Döndürür: APIEmptyResponse

Örnek

deleteNotificationCount Örneği

Copy

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

Önbelleğe Alınmış Bildirim Sayısını Al

Parametreler

İsim	Tip	Gerekli	Açıklama
tenantId	string	Yes
id	string	Yes

Yanıt

Döndürür: GetCachedNotificationCountResponse

Örnek

getCachedNotificationCount Örneği

Copy

auto tenantId = boost::optional<utility::string_t>(utility::conversions::to_string_t("my-tenant-123"));
auto userId = boost::optional<utility::string_t>(utility::conversions::to_string_t("user-456"));
api->getCachedNotificationCount(tenantId.value(), userId.value())
    .then([](pplx::task<std::shared_ptr<GetCachedNotificationCountResponse>> task) {
        try {
            auto response = task.get();
            // yanıtı işleyin
        } catch (const std::exception&) {
            // hatayı yakalayın
        }
    });

Bildirim Sayısını Al

Parametreler

Name	Type	Required	Description
tenantId	string	Evet
options	const GetNotificationCountOptions&	Evet

Yanıt

Döndürür: GetNotificationCountResponse

Örnek

getNotificationCount Örneği

Copy

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

Bildirimleri Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
options	const GetNotificationsOptions&	Yes

Yanıt

Döndürür: GetNotificationsResponse

Örnek

getNotifications Örneği

Copy

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

Bildirimi Güncelle

Parametreler

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

Yanıt

Döndürür: APIEmptyResponse

Örnek

updateNotification Örneği

Copy

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

V1 Sayfa Tepkisi Oluştur

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
urlId	string	Evet
title	string	Hayır

Yanıt

Döndürür: CreateV1PageReact

Örnek

createV1PageReact Örneği

Copy

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

V2 Sayfa Tepkisi Oluştur

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
id	string	Yes
title	string	No

Response

Returns: CreateV1PageReact

Example

createV2PageReact Örneği

Copy

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

V1 Sayfa Tepkisini Sil

Parametreler

İsim	Tür	Gerekli	Açıklama
tenantId	string	Yes
urlId	string	Yes

Yanıt

Döndürür: CreateV1PageReact

Örnek

deleteV1PageReact Örneği

Copy

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

V2 Sayfa Tepkisini Sil

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
urlId	string	Yes
id	string	Yes

Yanıt

Döndürür: CreateV1PageReact

Örnek

deleteV2PageReact Örneği

Copy

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

V1 Sayfa Beğenilerini Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
urlId	string	Evet

Yanıt

Döndürür: GetV1PageLikes

Örnek

getV1PageLikes Örneği

Copy

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

V2 Sayfa Tepkilerini Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
urlId	string	Yes

Yanıt

Döndürür: GetV2PageReacts

Örnek

getV2PageReacts Örneği

Copy

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

V2 Sayfa Tepki Veren Kullanıcıları Al

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
urlId	string	Yes
id	string	Yes

Yanıt

Döndürür: GetV2PageReactUsersResponse

Örnek

getV2PageReactUsers Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto urlId = utility::conversions::to_string_t("page-456");
auto id = utility::conversions::to_string_t("react-789");
boost::optional<utility::string_t> maybeFilter;
api->getV2PageReactUsers(tenantId, urlId, id).then([](pplx::task<std::shared_ptr<GetV2PageReactUsersResponse>> task){
    try{
        auto response = task.get();
        // Yanıtı gerektiği gibi kullan
    }catch(const std::exception&){
        // Hata işleyin
    }
});

Sayfa Ekle

Parameters

İsim	Tür	Gerekli	Açıklama
tenantId	string	Yes
createAPIPageData	CreateAPIPageData	Yes

Response

Döndürür: AddPageAPIResponse

Örnek

addPage Örneği

Copy

auto createData = CreateAPIPageData{};
createData.title = utility::string_t(U("Welcome Page"));
createData.url = utility::string_t(U("https://example.com/welcome"));
createData.description = boost::optional<utility::string_t>(utility::string_t(U("Landing page for new users")));
api->addPage(utility::string_t(U("my-tenant-123")), createData)
    .then([](std::shared_ptr<AddPageAPIResponse> response) {
        if (response && response->success) {
            // başarılı eklemeyi işle
        } else {
            // hatayı işle
        }
    });

Sayfayı Sil

Parametreler

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Yanıt

Döndürür: DeletePageAPIResponse

Örnek

deletePage Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto pageId   = utility::conversions::to_string_t("page-456");
api->deletePage(tenantId, pageId)
   .then([](pplx::task<std::shared_ptr<DeletePageAPIResponse>> t) {
       try {
           auto response = t.get();
           // yanıtı gerektiği gibi işleyin
       } catch (const std::exception& ex) {
           // hatayı ele al
       }
   });

Çevrimdışı Kullanıcıları Al

Sayfada daha önce yorum yapmış ancak şu anda çevrim içi olmayan yorumcular. displayName'e göre sıralanır.
Bu, /users/online endpoint'i tüketildikten sonra bir "Üyeler" bölümü oluşturmak için kullanılır.
commenterName üzerinde imleç sayfalama: sunucu, {tenantId, urlId, commenterName} kısmı üzerinden afterName'den itibaren $gt ile ileri yürür, $skip maliyeti yok.

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
urlId	string	Evet
options	const GetOfflineUsersOptions&	Evet

Yanıt

Döndürür: PageUsersOfflineResponse

Örnek

getOfflineUsers Örneği

Copy

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

Çevrimiçi Kullanıcıları Al

Şu anda çevrimiçi izleyiciler: Websocket oturumu şu anda sayfaya abone olan kişiler.
anonCount + totalCount değerini döndürür (odadaki tüm aboneler, numaralandırmadığımız anonim izleyiciler dahil).

Parameters

Ad	Tür	Gerekli
tenantId	string	Yes
urlId	string	Yes
options	const GetOnlineUsersOptions&	Yes

Response

Döndürür: PageUsersOnlineResponse

Example

getOnlineUsers Örneği

Copy

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

URL ID ile Sayfayı Al

Parametreler

Name	Type	Required	Description
tenantId	string	Yes
urlId	string	Yes

Yanıt

Döndürür: GetPageByURLIdAPIResponse

Örnek

getPageByURLId Örnek

Copy

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

Sayfaları Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet

Yanıt

Returns: GetPagesAPIResponse

Örnek

getPages Örneği

Copy

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

Sayfaları Al (Genel)

List pages for a tenant. Used by the FChat desktop client to populate its room list.
Requires enableFChat to be true on the resolved custom config for each page.
Pages that require SSO are filtered against the requesting user's group access.

Parameters

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
options	const GetPagesPublicOptions&	Evet

Yanıt

Döndürür: GetPublicPagesResponse

Örnek

getPagesPublic Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
GetPagesPublicOptions options;
options.limit = boost::optional<int>(50);
options.cursor = boost::optional<utility::string_t>(U("cursor-token"));
api->getPagesPublic(tenantId, options).then([](pplx::task<std::shared_ptr<GetPublicPagesResponse>> task){
    try{
        auto response = task.get();
        // gerekirse yanıtı işle
    }catch(const std::exception&){
        // gerekirse hatayı işle
    }
});

Kullanıcı Bilgilerini Al

Bulk user info for a tenant. Given userIds, return display info from User / SSOUser.
Used by the comment widget to enrich users that just appeared via a presence event.
No page context: privacy is enforced uniformly (private profiles are masked).

Parameters

Name	Type	Required	Description
tenantId	string	Yes
ids	string	Yes

Response

Döndürür: PageUsersInfoResponse

Example

getUsersInfo Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t ids = U("alice@example.com,bob@example.com");
boost::optional<utility::string_t> locale = boost::make_optional(U("en-US"));
api->getUsersInfo(tenantId, ids).then([](pplx::task<std::shared_ptr<PageUsersInfoResponse>> t){
    try{
        auto response = t.get();
        // yanıtı işle
    }catch(const std::exception&){
        // hatayı işle
    }
});

Sayfayı Kısmen Güncelle

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
id	string	Evet
updateAPIPageData	UpdateAPIPageData	Evet

Yanıt

Döndürür: PatchPageAPIResponse

Örnek

patchPage Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t pageId = U("page-789");
UpdateAPIPageData update;
update.title = boost::optional<utility::string_t>(U("Updated Page Title"));
update.metadata = boost::optional<utility::string_t>(U("{\"author\":\"jane.doe@example.com\"}"));
api->patchPage(tenantId, pageId, update)
    .then([](std::shared_ptr<PatchPageAPIResponse> response) {
        if (response && response->isSuccess) {
            // başarıyı işle
        }
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

Bekleyen Webhook Etkinliğini Sil

Parametreler

İsim	Tür	Gerekli	Açıklama
tenantId	string	Evet
id	string	Evet

Yanıt

Returns: APIEmptyResponse

Örnek

deletePendingWebhookEvent Örneği

Copy

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

Bekleyen Webhook Etkinliği Sayısını Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
options	const GetPendingWebhookEventCountOptions&	Evet

Yanıt

Döndürür: GetPendingWebhookEventCountResponse

Örnek

getPendingWebhookEventCount Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
GetPendingWebhookEventCountOptions opts;
opts.filter = boost::optional<utility::string_t>(utility::conversions::to_string_t("active"));
api->getPendingWebhookEventCount(tenantId, opts)
    .then([](std::shared_ptr<GetPendingWebhookEventCountResponse> resp){
        auto count = resp->getCount();
    });

Bekleyen Webhook Etkinliklerini Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
options	const GetPendingWebhookEventsOptions&	Evet

Yanıt

Döndürür: GetPendingWebhookEventsResponse

Örnek

getPendingWebhookEvents Örneği

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
GetPendingWebhookEventsOptions opts;
opts.pageSize = boost::optional<int>(100);
opts.startAfter = boost::optional<utility::string_t>(U("event-abc-456"));
api->getPendingWebhookEvents(tenantId, opts)
    .then([](pplx::task<std::shared_ptr<GetPendingWebhookEventsResponse>> task) {
        try {
            auto resp = task.get();
            auto copy = std::make_shared<GetPendingWebhookEventsResponse>(*resp);
        } catch (const std::exception&) {}
    });

Soru Yapılandırması Oluştur

Parametreler

İsim	Tür	Gerekli	Açıklama
tenantId	string	Evet
createQuestionConfigBody	CreateQuestionConfigBody	Evet

Yanıt

Döndürür: CreateQuestionConfigResponse

Örnek

createQuestionConfig Örneği

Copy

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

Soru Yapılandırmasını Sil

Parametreler

Ad	Tip	Gereklidir	Açıklama
tenantId	string	Evet
id	string	Evet

Yanıt

Döndürür: APIEmptyResponse

Örnek

deleteQuestionConfig Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto configId = utility::conversions::to_string_t("question-config-456");
api->deleteQuestionConfig(tenantId, configId)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // başarılı silme işlemini ele al
    })
    .then([](pplx::task<void> t) {
        try {
            t.get();
        } catch (const std::exception&) {
            // hatayı ele al
        }
    });

Soru Yapılandırmasını Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
id	string	Evet

Yanıt

Döndürür: GetQuestionConfigResponse

Örnek

getQuestionConfig Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto questionId = utility::conversions::to_string_t("question-456");
api->getQuestionConfig(tenantId, questionId)
    .then([](pplx::task<std::shared_ptr<GetQuestionConfigResponse>> task) {
        try {
            auto response = task.get();
            // Gerekli olduğu gibi yanıtı kullan
        } catch (const std::exception&) {
            // Hata işleyin
        }
    });

Soru Yapılandırmalarını Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
skip	double	No

Yanıt

Döndürür: GetQuestionConfigsResponse

Örnek

getQuestionConfigs Örneği

Copy

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

Soru Yapılandırmasını Güncelle

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
id	string	Evet
updateQuestionConfigBody	UpdateQuestionConfigBody	Evet

Yanıt

Döndürür: APIEmptyResponse

Örnek

updateQuestionConfig Örneği

Copy

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

Soru Sonucu Oluştur

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
createQuestionResultBody	CreateQuestionResultBody	Yes

Yanıt

Döndürür: CreateQuestionResultResponse

Örnek

createQuestionResult Örneği

Copy

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

Soru Sonucunu Sil

Parametreler

İsim	Tür	Gerekli	Açıklama
tenantId	string	Evet
id	string	Evet

Yanıt

Döndürür: APIEmptyResponse

Örnek

deleteQuestionResult Örneği

Copy

boost::optional<utility::string_t> optTenant = utility::conversions::to_string_t( "my-tenant-123" );
utility::string_t questionId = utility::conversions::to_string_t( "question-456" );
if ( optTenant )
{
    api->deleteQuestionResult( *optTenant, questionId )
        .then( []( pplx::task<std::shared_ptr<APIEmptyResponse>> t )
        {
            try
            {
                auto resp = t.get();
                // başarı işleme
            }
            catch ( const std::exception& e )
            {
                // hata işleme
            }
        } );
}

Soru Sonucunu Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
id	string	Evet

Yanıt

Döndürür: GetQuestionResultResponse

Örnek

getQuestionResult Örneği

Copy

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

Soru Sonuçlarını Al

Parametreler

Ad	Tip	Gerekli	Açıklama
tenantId	string	Evet
options	const GetQuestionResultsOptions&	Evet

Yanıt

Döndürür: GetQuestionResultsResponse

Örnek

getQuestionResults Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
GetQuestionResultsOptions options;
options.questionId = boost::optional<utility::string_t>(U("question-456"));
options.includeDeleted = boost::optional<bool>(false);
api->getQuestionResults(tenantId, options)
    .then([](pplx::task<std::shared_ptr<GetQuestionResultsResponse>> t) {
        auto response = t.get();
        // yanıtı işle
    });

Soru Sonucunu Güncelle

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
id	string	Yes
updateQuestionResultBody	UpdateQuestionResultBody	Yes

Yanıt

Döndürür: APIEmptyResponse

Örnek

updateQuestionResult Örneği

Copy

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

Soru Sonuçlarını Topla

Parametreler

Ad	Tip	Gerekli	Açıklama
tenantId	string	Evet
options	const AggregateQuestionResultsOptions&	Evet

Yanıt

Döner: AggregateQuestionResultsResponse

Örnek

aggregateQuestionResults Örneği

Copy

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

Soru Sonuçlarını Toplu Olarak Topla

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Evet
forceRecalculate	bool	Hayır

Yanıt

Döndürür: BulkAggregateQuestionResultsResponse

Örnek

bulkAggregateQuestionResults Örneği

Copy

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

Yorumları Soru Sonuçlarıyla Birleştir

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
options	const CombineCommentsWithQuestionResultsOptions&	Evet

Yanıt

Döndürür: CombineQuestionResultsWithCommentsResponse

Örnek

combineCommentsWithQuestionResults Örneği

Copy

utility::string_t tenantId = utility::string_t("my-tenant-123");
CombineCommentsWithQuestionResultsOptions options;
options.questionId = utility::string_t("question-789");
options.maxComments = boost::optional<int>(50);
api->combineCommentsWithQuestionResults(tenantId, options).then(
    [](pplx::task<std::shared_ptr<CombineQuestionResultsWithCommentsResponse>> task){
        try{
            auto respPtr = task.get();
            auto combined = std::make_shared<CombineQuestionResultsWithCommentsResponse>(*respPtr);
            // Gerekli olduğunda combined'ı kullan
        }catch(const std::exception&){
        }
    });

SSO Kullanıcısı Ekle

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
createAPISSOUserData	CreateAPISSOUserData	Evet

Yanıt

Döndürür: AddSSOUserAPIResponse

Örnek

addSSOUser Örneği

Copy

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

SSO Kullanıcısını Sil

Parameters

Ad	Tür	Gerekli
tenantId	string	Evet
id	string	Evet
options	const DeleteSSOUserOptions&	Evet

Yanıt

Döndürür: DeleteSSOUserAPIResponse

Örnek

deleteSSOUser Örneği

Copy

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

E-posta ile SSO Kullanıcısını Al

Parametreler

Name	Type	Required	Description
tenantId	string	Yes
email	string	Yes

Yanıt

Döndürür: GetSSOUserByEmailAPIResponse

Örnek

getSSOUserByEmail Örneği

Copy

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

ID ile SSO Kullanıcısını Al

Parametreler

Ad	Tür	Gereki ri	Açıklama
tenantId	string	Evet
id	string	Evet

Yanıt

Döndürür: GetSSOUserByIdAPIResponse

Örnek

getSSOUserById Örneği

Copy

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

SSO Kullanıcılarını Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
skip	int32_t	Hayır

Yanıt

Döndürür: GetSSOUsersResponse

Örnek

getSSOUsers Örneği

Copy

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

SSO Kullanıcısını Kısmen Güncelle

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
id	string	Evet
updateAPISSOUserData	UpdateAPISSOUserData	Evet
updateComments	bool	Hayır

Yanıt

Döndürür: PatchSSOUserAPIResponse

Örnek

patchSSOUser Örneği

Copy

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

SSO Kullanıcısını Değiştir

Parametreler

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateAPISSOUserData	UpdateAPISSOUserData	Yes
updateComments	bool	No

Yanıt

Döndürür: PutSSOUserAPIResponse

Örnek

putSSOUser Örnek

Copy

UpdateAPISSOUserData userData;
userData.email = utility::conversions::to_string_t("alice@example.com");
userData.first_name = utility::conversions::to_string_t("Alice");
userData.last_name = utility::conversions::to_string_t("Smith");
userData.role = utility::conversions::to_string_t("moderator");
api->putSSOUser(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("alice.smith"),
    userData,
    boost::optional<bool>(true)
).then([](pplx::task<std::shared_ptr<PutSSOUserAPIResponse>> t) {
    auto response = t.get();
});

Abonelik Oluştur

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Evet

Yanıt

Döndürür: CreateSubscriptionAPIResponse

Örnek

createSubscription Örneği

Copy

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

Aboneliği Sil

Parameters

Ad	Tür	Gereklidir
tenantId	string	Evet
id	string	Evet
userId	string	Hayır

Response

Döndürür: DeleteSubscriptionAPIResponse

Example

deleteSubscription Örneği

Copy

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

Abonelikleri Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
userId	string	Hayır

Yanıt

Döndürür: GetSubscriptionsAPIResponse

Örnek

getSubscriptions Örneği

Copy

auto tenant = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> user = utility::conversions::to_string_t("user@example.com");
api->getSubscriptions(tenant, user).then(
    [](pplx::task<std::shared_ptr<GetSubscriptionsAPIResponse>> t) {
        try {
            auto response = t.get();
            // yanıtı işle
        } catch (const std::exception& e) {
            // hatayı işle
        }
    }
);

Aboneliği Güncelle

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
id	string	Evet
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	Evet
userId	string	Hayır

Yanıt

Döndürür: UpdateSubscriptionAPIResponse

Örnek

updateSubscription Örneği

Copy

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

Kiracı Günlük Kullanımlarını Al

Parameters

Ad	Tip	Gerekli	Açıklama
tenantId	string	Evet
options	const GetTenantDailyUsagesOptions&	Evet

Response

Döndürür: GetTenantDailyUsagesResponse

Örnek

getTenantDailyUsages Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
GetTenantDailyUsagesOptions opts;
opts.startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-01T00:00:00Z")));
opts.endDate   = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-31T23:59:59Z")));
api->getTenantDailyUsages(tenantId, opts).then([](std::shared_ptr<GetTenantDailyUsagesResponse> resp){
    auto result = std::make_shared<GetTenantDailyUsagesResponse>(*resp);
}).wait();

Kiracı Paketi Oluştur

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
createTenantPackageBody	CreateTenantPackageBody	Evet

Yanıt

Döndürür: CreateTenantPackageResponse

Örnek

createTenantPackage Örneği

Copy

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

Kiracı Paketini Sil

Parametreler

İsim	Tür	Gerekli	Açıklama
tenantId	string	Evet
id	string	Evet

Yanıt

Döndürür: APIEmptyResponse

Örnek

deleteTenantPackage Örneği

Copy

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

Kiracı Paketini Al

Parametreler

İsim	Tür	Gerekli	Açıklama
tenantId	string	Evet
id	string	Evet

Yanıt

Döndürür: GetTenantPackageResponse

Örnek

getTenantPackage Örneği

Copy

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

Kiracı Paketlerini Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
skip	double	No

Yanıt

Döndürür: GetTenantPackagesResponse

Örnek

getTenantPackages Örneği

Copy

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

Kiracı Paketini Değiştir

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
id	string	Yes
replaceTenantPackageBody	ReplaceTenantPackageBody	Yes

Yanıt

Döndürür: APIEmptyResponse

Örnek

replaceTenantPackage Örneği

Copy

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

Kiracı Paketini Güncelle

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
id	string	Evet
updateTenantPackageBody	UpdateTenantPackageBody	Evet

Yanıt

Döndürür: APIEmptyResponse

Örnek

updateTenantPackage Örneği

Copy

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

Kiracı Kullanıcısı Oluştur

Parametreler

Name	Type	Required	Description
tenantId	string	Yes
createTenantUserBody	CreateTenantUserBody	Yes

Yanıt

Döndürür: CreateTenantUserResponse

Örnek

createTenantUser Örneği

Copy

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

Kiracı Kullanıcısını Sil

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
id	string	Evet
options	const DeleteTenantUserOptions&	Evet

Yanıt

Döndürür: APIEmptyResponse

Örnek

deleteTenantUser Örneği

Copy

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

Kiracı Kullanıcısını Al

Parameters

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
id	string	Evet

Response

Döndürür: GetTenantUserResponse

Örnek

getTenantUser Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user@example.com");
api->getTenantUser(tenantId, userId)
    .then([](pplx::task<std::shared_ptr<GetTenantUserResponse>> task) {
        try {
            auto response = task.get();
            // Gerekli olduğu gibi yanıtı kullanın
        } catch (const std::exception&) {
            // Hata işleme
        }
    });

Kiracı Kullanıcılarını Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
skip	double	Hayır

Yanıt

Döndürür: GetTenantUsersResponse

Örnek

getTenantUsers Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<double> skip = 10;
api->getTenantUsers(tenantId, skip).then([](pplx::task<std::shared_ptr<GetTenantUsersResponse>> t){
    try {
        auto resp = t.get();
    } catch (const std::exception&) {
    }
});

Kiracı Kullanıcısını Değiştir

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
id	string	Yes
replaceTenantUserBody	ReplaceTenantUserBody	Yes
updateComments	string	No

Yanıt

Döndürür: APIEmptyResponse

Örnek

replaceTenantUser Örneği

Copy

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

Giriş Bağlantısı Gönder

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
id	string	Evet
redirectURL	string	Hayır

Yanıt

Döndürür: APIEmptyResponse

Örnek

sendLoginLink Örnek

Copy

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

Kiracı Kullanıcısını Güncelle

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
id	string	Evet
updateTenantUserBody	UpdateTenantUserBody	Evet
updateComments	string	Hayır

Yanıt

Döndürür: APIEmptyResponse

Örnek

updateTenantUser Örneği

Copy

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

Kiracı Oluştur

Parametreler

Ad	Tip	Gerekli	Açıklama
tenantId	string	Yes
createTenantBody	CreateTenantBody	Yes

Yanıt

Dönüş: CreateTenantResponse

Örnek

createTenant Örneği

Copy

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

Kiracıyı Sil

Parametreler

Ad	Tür	Zorunlu
tenantId	string	Evet
id	string	Evet
sure	string	Hayır

Yanıt

Döndürür: APIEmptyResponse

Örnek

deleteTenant Örneği

Copy

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

Kiracıyı Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
id	string	Evet

Yanıt

Döner: GetTenantResponse

Örnek

getTenant Örneği

Copy

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

Kiracıları Al

Parametreler

Name	Type	Required	Description
tenantId	string	Yes
options	const GetTenantsOptions&	Yes

Yanıt

Döndürür: GetTenantsResponse

Örnek

getTenants Örneği

Copy

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

Kiracıyı Güncelle

Parametreler

Ad	Tip	Gerekli
tenantId	string	Evet
id	string	Evet
updateTenantBody	UpdateTenantBody	Evet

Yanıt

Döndürür: APIEmptyResponse

Örnek

updateTenant Örneği

Copy

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

Bilet Durumunu Değiştir

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
userId	string	Yes
id	string	Yes
changeTicketStateBody	ChangeTicketStateBody	Yes

Yanıt

Döndürür: ChangeTicketStateResponse

Örnek

changeTicketState Örneği

Copy

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

Bilet Oluştur

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
userId	string	Yes
createTicketBody	CreateTicketBody	Yes

Yanıt

Döndürür: CreateTicketResponse

Örnek

createTicket Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("john.doe@example.com");
CreateTicketBody ticketBody;
ticketBody.setSubject(utility::conversions::to_string_t("Login Issue"));
ticketBody.setDescription(utility::conversions::to_string_t("Cannot log in after password reset."));
boost::optional<int> priority = 2;
ticketBody.setPriority(priority);
api->createTicket(tenantId, userId, ticketBody).then([](pplx::task<std::shared_ptr<CreateTicketResponse>> task){
    try{
        auto response = task.get();
        // Use response as needed
    }catch(const std::exception&){
        // Handle error
    }
});

Bileti Al

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
id	string	Evet
userId	string	Hayır

Yanıt

Döndürür: GetTicketResponse

Örnek

getTicket Örneği

Copy

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

Biletleri Al

Parametreler

Ad	Tip	Gerekli	Açıklama
tenantId	string	Evet
options	const GetTicketsOptions&	Evet

Yanıt

Döndürür: GetTicketsResponse

Örnek

getTickets Örneği

Copy

auto options = GetTicketsOptions{};
options.page = boost::optional<int>(1);
options.status = boost::optional<utility::string_t>(U("open"));
api->getTickets(U("my-tenant-123"), options).then([](pplx::task<std::shared_ptr<GetTicketsResponse>> task) {
    try {
        auto response = task.get();
        auto responseCopy = std::make_shared<GetTicketsResponse>(*response);
    } catch (const std::exception&) {
    }
});

Çevirileri Al

Parametreler

Ad	Tür	Gerekli
r_namespace	string	Evet
component	string	Evet
options	const GetTranslationsOptions&	Evet

Yanıt

Döndürür: GetTranslationsResponse

Örnek

getTranslations Örneği

Copy

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

Resim Yükle

Bir resmi yükle ve yeniden boyutlandır

Parametreler

İsim	Tür	Gerekli
tenantId	string	Yes
file	HttpContent	Yes
options	const UploadImageOptions&	Yes

Yanıt

Döndürür: UploadImageResponse

Örnek

uploadImage Örneği

Copy

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

ID ile Kullanıcı Rozet İlerleme Durumunu Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
id	string	Yes

Yanıt

Döndürür: APIGetUserBadgeProgressResponse

Örnek

getUserBadgeProgressById Örneği

Copy

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

Kullanıcı ID ile Rozet İlerlemesini Al

Parametreler

Ad	Tip	Gerekli	Açıklama
tenantId	string	Evet
userId	string	Evet

Yanıt

Döndürür: APIGetUserBadgeProgressResponse

Örnek

getUserBadgeProgressByUserId Örneği

Copy

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

Kullanıcı Rozet İlerleme Listesini Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
options	const GetUserBadgeProgressListOptions&	Yes

Yanıt

Döndürür: APIGetUserBadgeProgressListResponse

Örnek

getUserBadgeProgressList Örneği

Copy

utility::string_t tenantId = U("my-tenant-123");
GetUserBadgeProgressListOptions options;
options.userId = U("user@example.com");
options.page = boost::optional<int>(1);
options.pageSize = boost::optional<int>(20);
api->getUserBadgeProgressList(tenantId, options)
    .then([](std::shared_ptr<APIGetUserBadgeProgressListResponse> resp) {
        if (!resp) return;
        for (const auto& badge : resp->badges) {
            // badge'ı işleyin
        }
    });

Kullanıcı Rozeti Oluştur

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
createUserBadgeParams	CreateUserBadgeParams	Evet

Yanıt

Döndürür: APICreateUserBadgeResponse

Örnek

createUserBadge Örneği

Copy

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

Kullanıcı Rozetini Sil

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
id	string	Evet

Yanıt

Döndürür: APIEmptySuccessResponse

Örnek

deleteUserBadge Örneği

Copy

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

Kullanıcı Rozetini Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
id	string	Evet

Yanıt

Döner: APIGetUserBadgeResponse

Örnek

getUserBadge Örneği

Copy

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

Kullanıcı Rozetlerini Al

Parametreler

Name	Type	Required	Description
tenantId	string	Yes
options	const GetUserBadgesOptions&	Yes

Yanıt

Döndürür: APIGetUserBadgesResponse

Örnek

getUserBadges Örneği

Copy

GetUserBadgesOptions opts;
opts.userId = boost::make_optional(U("user@example.com"));
opts.includeExpired = boost::make_optional(false);
api->getUserBadges(U("my-tenant-123"), opts)
   .then([](pplx::task<std::shared_ptr<APIGetUserBadgesResponse>> t) {
       try {
           auto response = t.get();
       } catch (const std::exception&) {
       }
   });

Kullanıcı Rozetini Güncelle

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
id	string	Yes
updateUserBadgeParams	UpdateUserBadgeParams	Yes

Yanıt

Döndürür: APIEmptySuccessResponse

Örnek

updateUserBadge Örneği

Copy

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

Kullanıcı Bildirim Sayısını Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
sso	string	Hayır

Yanıt

Döndürür: GetUserNotificationCountResponse

Örnek

getUserNotificationCount Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("user@example.com");
api->getUserNotificationCount(tenantId, sso).then([](pplx::task<std::shared_ptr<GetUserNotificationCountResponse>> t){
    try{
        auto resp = t.get();
        // resp'yi gerektiği gibi kullan
    }catch(const std::exception&){
        // hatayı ele al
    }
});

Kullanıcı Bildirimlerini Al

Parameters

Name	Type	Required	Description
tenantId	string	Yes
options	const GetUserNotificationsOptions&	Yes

Response

Returns: GetMyNotificationsResponse

Example

getUserNotifications Örneği

Copy

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

Kullanıcı Bildirim Sayısını Sıfırla

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
sso	string	Hayır

Yanıt

Döndürür: ResetUserNotificationsResponse

Örnek

resetUserNotificationCount Örneği

Copy

auto resetTask = api->resetUserNotificationCount(
    U("my-tenant-123"),
    boost::optional<utility::string_t>(U("user@example.com"))
).then([](std::shared_ptr<ResetUserNotificationsResponse> resp){
});

Kullanıcı Bildirimlerini Sıfırla

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Yes
options	const ResetUserNotificationsOptions&	Yes

Yanıt

Döndürür: ResetUserNotificationsResponse

Örnek

resetUserNotifications Örneği

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
ResetUserNotificationsOptions options;
options.email = boost::optional<utility::string_t>(U("user@example.com"));
api->resetUserNotifications(tenantId, options)
    .then([](std::shared_ptr<ResetUserNotificationsResponse> resp) {
        // Yanıtı işle
    });

Kullanıcı Bildirim Yorum Abonelik Durumunu Güncelle

Enable or disable notifications for a specific comment.

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
notificationId	string	Evet
optedInOrOut	string	Evet
commentId	string	Evet
sso	string	Hayır

Yanıt

Döndürür: UpdateUserNotificationCommentSubscriptionStatusResponse

Örnek

updateUserNotificationCommentSubscriptionStatus Örneği

Copy

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

Kullanıcı Sayfa Abonelik Durumunu Güncelle

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

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
url	string	Yes
pageTitle	string	Yes
subscribedOrUnsubscribed	string	Yes
sso	string	No

Response

Returns: UpdateUserNotificationPageSubscriptionStatusResponse

Example

updateUserNotificationPageSubscriptionStatus Örneği

Copy

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

Kullanıcı Bildirim Durumunu Güncelle

Parametreler

İsim	Tür	Gerekli
tenantId	string	Evet
notificationId	string	Evet
newStatus	string	Evet
sso	string	Hayır

Yanıt

Döndürür: UpdateUserNotificationStatusResponse

Örnek

updateUserNotificationStatus Örneği

Copy

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

Kullanıcı Varlık Durumlarını Al

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
urlIdWS	string	Yes
userIds	string	Yes

Yanıt

Döndürür: GetUserPresenceStatusesResponse

Örnek

getUserPresenceStatuses Örneği

Copy

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

Kullanıcı Ara

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
urlId	string	Evet
options	const SearchUsersOptions&	Evet

Yanıt

Döndürür: SearchUsersResult

Örnek

searchUsers Örneği

Copy

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

Kullanıcıyı Al

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Döndürür: GetUserResponse

Örnek

getUser Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user-789");
boost::optional<utility::string_t> optTag = boost::none;
api->getUser(tenantId, userId)
    .then([=](pplx::task<std::shared_ptr<GetUserResponse>> task) {
        try {
            auto response = task.get();
            if (!response) {
                response = std::make_shared<GetUserResponse>();
            }
            // gerektiği gibi yanıtı işleyin
        } catch (const std::exception&) {
            // hatayı ele alın
        }
    });

Oy Oluştur

Parametreler

Ad	Tür	Gerekli
tenantId	string	Evet
commentId	string	Evet
direction	string	Evet
options	const CreateVoteOptions&	Evet

Yanıt

Döndürür: VoteResponse

Örnek

createVote Örneği

Copy

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

Oyu Sil

Parametreler

İsim	Tip	Gerekli
tenantId	string	Yes
id	string	Yes
editKey	string	No

Yanıt

Döndürür: VoteDeleteResponse

Örnek

deleteVote Örneği

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto voteId = utility::conversions::to_string_t("vote-9876");
boost::optional<utility::string_t> editKey = utility::conversions::to_string_t("edit-abc123");
api->deleteVote(tenantId, voteId, editKey).then([](pplx::task<std::shared_ptr<VoteDeleteResponse>> task) {
    try {
        auto response = task.get();
        // Gerekli olduğu gibi yanıtı işleyin
    } catch (const std::exception&) {
        // Hata işleyin
    }
});

Oyları Al

Parametreler

Ad	Tür	Gerekli	Açıklama
tenantId	string	Evet
urlId	string	Evet

Yanıt

Döndürür: GetVotesResponse

Örnek

getVotes Örneği

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto urlId = utility::string_t(U("article-456"));
boost::optional<utility::string_t> extraHeader = boost::none;
api->getVotes(tenantId, urlId).then([=](pplx::task<std::shared_ptr<GetVotesResponse>> task) {
    try {
        auto original = task.get();
        auto response = std::make_shared<GetVotesResponse>(*original);
    } catch (...) {
        // hata işleme
    }
});

Kullanıcı İçin Oyları Al

Parametreler

Ad	Tür	Gerekli
tenantId	string	Yes
urlId	string	Yes
options	const GetVotesForUserOptions&	Yes

Yanıt

Döndürür: GetVotesForUserResponse

Örnek

getVotesForUser Örneği

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto urlId = utility::string_t(U("post-456"));
GetVotesForUserOptions options;
options.page = boost::optional<int>(2);
options.pageSize = boost::optional<int>(50);
api->getVotesForUser(tenantId, urlId, options).then([](std::shared_ptr<GetVotesForUserResponse> response) {
    if (response) {
        // yanıtı işle, ör. oyları döngüyle dolaş
    }
});

Yardıma mı ihtiyacınız var?

C++ SDK ile ilgili herhangi bir sorunla karşılaşırsanız veya sorularınız olursa, lütfen:

Katkıda Bulunma

Katkılar memnuniyetle karşılanır! Katkı yönergeleri için lütfen GitHub deposunu ziyaret edin.

Dil 🇹🇷 Türkçe

Dokümantasyon

Başlarken

API Referansı

Kullanım

Toplama

Denetim Kayıtları

Kimlik Doğrulama

Yorumdan Engelleme

Engellenen Yorumları Kontrol Et

Yorumlar

Kullanıcı İçin Yorumlar

Etki Alanı Yapılandırmaları

E-posta Şablonları

Olay Günlüğü

Akış Gönderileri

Yorumu İşaretle

GIF'ler

Hashtag'ler

Moderasyon

Moderatörler

Bildirim Sayısı

Bildirimler

Sayfa Tepkileri

Sayfalar

Bekleyen Webhook Etkinlikleri

Soru Yapılandırmaları

Soru Sonuçları

Soru Sonuçları Toplama

SSO Kullanıcıları

Abonelikler

Kiracı Günlük Kullanımı

Kiracı Paketleri

Kiracı Kullanıcıları

Kiracılar

Biletler

Çeviriler

Resim Yükleme

Kullanıcı Rozet İlerlemesi

Kullanıcı Rozetleri

Kullanıcı Bildirimleri

Kullanıcı Varlık Durumu

Kullanıcı Arama

Kullanıcılar

Oylar

FastComments C++ SDK

Depo

Gereksinimler

Kurulum

Bağımlılıkları Yükleme

Kaynağından Derleme

Kurulum

Kütüphane İçeriği

Genel ve Güvenli API'lar

Hızlı Başlangıç

Kimlik Doğrulamalı API'leri Kullanma (DefaultAPI)

Genel API'leri Kullanma (PublicAPI)

Moderatör API'lerini Kullanma (ModerationApi)

Ortak Sorunlar

API Çağrısı Yapma: Senkron vs Asenkron

.get() ile Eşzamanlı Çağrılar

.then() ile Asenkron Çağrılar

Eşzamanlı ve Asenkron Arasında Seçim Yapmak

Notlar

Yayın Kimlikleri

SSO (Tek Oturum Açma)

SSO Kullanımı

Basit SSO

Güvenli SSO

fastcomments için Dokümantasyon

API Uç Noktaları İçin Dokümantasyon

Modeller İçin Dokümantasyon

Topla

Parametreler

Yanıt

Örnek

Denetim Kayıtlarını Al

Parametreler

Yanıt

Örnek

`.get()` ile Eşzamanlı Çağrılar

`.then()` ile Asenkron Çağrılar