A API de comentários para discussões ao vivo

# Fetch comments for a page
curl -s 'https://fastcomments.com/api/v1/comments?tenantId=your-tenant-id&urlId=page-url-id' \
  -H 'x-api-key: YOUR_API_KEY'

import client
from client.api.public_api import GetCommentsPublicOptions

configuration = client.Configuration(host="https://fastcomments.com")
with client.ApiClient(configuration) as api_client:
    api = client.PublicApi(api_client)
    response = api.get_comments_public(
        "your-tenant-id",
        "page-url-id",
        GetCommentsPublicOptions(page=0, limit=30),
    )
    for comment in response.comments:
        print(comment.commenter_name, comment.comment)

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api = new FastComments\Client\Api\PublicApi(new GuzzleHttp\Client());

$result = $api->getCommentsPublic('your-tenant-id', 'page-url-id', [
    'page'  => 0,
    'limit' => 30,
]);

foreach ($result->getComments() as $comment) {
    echo $comment->getCommenterName() . ': ' . $comment->getComment() . PHP_EOL;
}

require 'fastcomments-client'

api = FastCommentsClient::PublicApi.new
result = api.get_comments_public('your-tenant-id', 'page-url-id', { page: 0, limit: 30 })

result.comments.each do |comment|
  puts "#{comment.commenter_name}: #{comment.comment}"
end

package main

import (
	"context"
	"fmt"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)

func main() {
	client := openapiclient.NewAPIClient(openapiclient.NewConfiguration())

	resp, _, err := client.PublicAPI.
		GetCommentsPublic(context.Background(), "your-tenant-id").
		UrlId("page-url-id").Page(0).Limit(30).Execute()
	if err != nil {
		panic(err)
	}
	for _, c := range resp.Comments {
		fmt.Printf("%s: %s\n", c.GetCommenterName(), c.GetComment())
	}
}

import com.fastcomments.invoker.ApiClient;
import com.fastcomments.invoker.Configuration;
import com.fastcomments.api.PublicApi;

ApiClient client = Configuration.getDefaultApiClient();
client.setBasePath("https://fastcomments.com");

PublicApi api = new PublicApi(client);
var result = api.getCommentsPublic("your-tenant-id", "page-url-id")
                .page(0)
                .limit(30)
                .execute();
System.out.println(result.getComments());

use fastcomments_sdk::client::apis::configuration::Configuration;
use fastcomments_sdk::client::apis::public_api::{get_comments_public, GetCommentsPublicParams};

let config = Configuration::new();
let params = GetCommentsPublicParams {
    tenant_id: "your-tenant-id".to_string(),
    url_id: "page-url-id".to_string(),
    page: Some(0),
    limit: Some(30),
    ..Default::default()
};
let result = get_comments_public(&config, params).await.unwrap();
for comment in result.comments {
    println!("{:?}: {:?}", comment.commenter_name, comment.comment);
}

import FastCommentsSwift

var options = PublicAPI.GetCommentsPublicOptions()
options.page = 0
options.limit = 30

let result = try await PublicAPI.getCommentsPublic(
    tenantId: "your-tenant-id",
    urlId: "page-url-id",
    options: options
)
print(result.comments ?? [])

#include "FastCommentsClient/api/PublicApi.h"
#include "FastCommentsClient/ApiClient.h"
#include "FastCommentsClient/ApiConfiguration.h"

using namespace org::openapitools::client::api;

auto config = std::make_shared<ApiConfiguration>();
config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

PublicApi publicApi(std::make_shared<ApiClient>(config));

auto resp = publicApi.getCommentsPublic(
    utility::conversions::to_string_t("your-tenant-id"),
    utility::conversions::to_string_t("page-url-id")
).get();