FastComments Python SDK

To jest oficjalne SDK Pythona dla FastComments.

Oficjalne SDK Pythona dla API FastComments

Repozytorium

Instalacja

PyPI

pip install fastcomments

Library Contents

Ta biblioteka zawiera dwa moduły: wygenerowanego klienta API oraz główną bibliotekę Pythona, która zawiera ręcznie napisane narzędzia ułatwiające pracę z API, w tym obsługę SSO.

Publiczne vs zabezpieczone API

Dla klienta API są dwie klasy, DefaultApi i PublicApi. DefaultApi zawiera metody, które wymagają twojego klucza API, natomiast PublicApi zawiera wywołania API, które można wykonywać bezpośrednio z przeglądarki/urządzenia mobilnego itp. bez uwierzytelniania.

Szybki start

Korzystanie z uwierzytelnionych API (DefaultApi)

Ważne: Musisz ustawić swój klucz API w Configuration przed wykonywaniem uwierzytelnionych żądań. Jeśli tego nie zrobisz, żądania zakończą się błędem 401.

from client import ApiClient, Configuration, DefaultApi
from client.models import CreateAPISSOUserData

# Utwórz i skonfiguruj klienta API
config = Configuration()
config.host = "https://fastcomments.com/api"

# WYMAGANE: Ustaw swój klucz API (pobierz go z panelu FastComments)
config.api_key = {"ApiKeyAuth": "YOUR_API_KEY_HERE"}

# Utwórz instancję API z skonfigurowanym klientem
api_client = ApiClient(configuration=config)
api = DefaultApi(api_client)

# Teraz możesz wykonywać uwierzytelnione wywołania API
try:
    # Przykład: Dodaj użytkownika SSO
    user_data = CreateAPISSOUserData(
        id="user-123",
        email="user@example.com",
        display_name="John Doe"
    )

    response = api.add_sso_user(
        tenant_id="YOUR_TENANT_ID",
        create_apisso_user_data=user_data
    )
    print(f"User created: {response}")

except Exception as e:
    print(f"Error: {e}")
    # Typowe błędy:
    # - 401: Brakujący lub nieprawidłowy klucz API
    # - 400: Walidacja żądania nie powiodła się

Korzystanie z publicznych API (PublicApi)

Publiczne endpointy nie wymagają uwierzytelnienia:

from client import ApiClient, Configuration, PublicApi

config = Configuration()
config.host = "https://fastcomments.com/api"

api_client = ApiClient(configuration=config)
public_api = PublicApi(api_client)

try:
    response = public_api.get_comments_public(
        tenant_id="YOUR_TENANT_ID",
        url_id="page-url-id"
    )
    print(response)
except Exception as e:
    print(f"Error: {e}")

Korzystanie z SSO (Single Sign-On)

SDK zawiera narzędzia do generowania bezpiecznych tokenów SSO:

from sso import FastCommentsSSO, SecureSSOUserData

# Utwórz dane użytkownika
user_data = SecureSSOUserData(
    user_id="user-123",
    email="user@example.com",
    username="johndoe",
    avatar="https://example.com/avatar.jpg"
)

# Utwórz instancję SSO z Twoim sekretem API
sso = FastCommentsSSO.new_secure(
    api_secret="YOUR_API_SECRET",
    user_data=user_data
)

# Wygeneruj token SSO
sso_token = sso.create_token()

# Użyj tego tokenu w frontendzie lub przekaż do wywołań API
print(f"SSO Token: {sso_token}")

Dla prostego SSO (mniej bezpieczne, do testów):

from sso import FastCommentsSSO, SimpleSSOUserData

user_data = SimpleSSOUserData(
    user_id="user-123",
    email="user@example.com"
)

sso = FastCommentsSSO.new_simple(user_data)
sso_token = sso.create_token()

Częste problemy

401 "missing-api-key" error: Upewnij się, że ustawisz config.api_key = {"ApiKeyAuth": "YOUR_KEY"} przed utworzeniem instancji DefaultApi.
Zła klasa API: Użyj DefaultApi dla uwierzytelnionych żądań po stronie serwera, PublicApi dla żądań po stronie klienta/publicznych.
Błędy importu: Upewnij się, że importujesz z poprawnego modułu:
- API client: from client import ...
- SSO utilities: from sso import ...

Notatki

Identyfikatory Broadcast

Zobaczysz, że w niektórych wywołaniach API powinieneś przekazać broadcast_id. Kiedy otrzymasz zdarzenia, otrzymasz ten identyfikator z powrotem, dzięki czemu będziesz wiedzieć, aby zignorować zdarzenie, jeśli zamierzasz optymistycznie zastosować zmiany po stronie klienta (co prawdopodobnie będziesz chciał zrobić, ponieważ zapewnia to najlepsze doświadczenie). Przekaż tutaj UUID. Identyfikator powinien być na tyle unikalny, żeby nie wystąpił dwukrotnie w sesji przeglądarki.

Wymagania

Python >= 3.8
urllib3 >= 1.25.3
python-dateutil >= 2.8.2
pydantic >= 2.0.0
typing-extensions >= 4.0.0

aggregate

Agreguje dokumenty, grupując je (jeśli podano groupBy) i stosując wiele operacji. Obsługiwane są różne operacje (np. sum, countDistinct, avg itp.).

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Tak
parentTenantId	string	query	Nie
includeStats	boolean	query	Nie

Odpowiedź

Zwraca: AggregationResponse

Przykład

Przykład aggregate

Copy

import client
from client.models.aggregation_request import AggregationRequest
from client.models.aggregation_response import AggregationResponse
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z zasadami bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację za pomocą klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    aggregation_request = client.AggregationRequest() # AggregationRequest | 
    parent_tenant_id = 'parent_tenant_id_example' # str |  (optional)
    include_stats = True # bool |  (optional)
    try:
        api_response = api_instance.aggregate(tenant_id, aggregation_request, parent_tenant_id=parent_tenant_id, include_stats=include_stats)
        print("The response of DefaultApi->aggregate:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->aggregate: %s\n" % e)

get_audit_logs

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Tak
limit	number	query	Nie
skip	number	query	Nie
order	string	query	Nie
after	number	query	Nie
before	number	query	Nie

Odpowiedź

Zwraca: GetAuditLogs200Response

Przykład

Przykład get_audit_logs

Copy

import client
from client.models.get_audit_logs200_response import GetAuditLogs200Response
from client.models.sortdir import SORTDIR
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania — użyj tego,
# który odpowiada Twojemu przypadkowi użycia.
# Konfiguracja autoryzacji kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzeba
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    limit = 3.4 # float |  (opcjonalne)
    skip = 3.4 # float |  (opcjonalne)
    order = client.SORTDIR() # SORTDIR |  (opcjonalne)
    after = 3.4 # float |  (opcjonalne)
    before = 3.4 # float |  (opcjonalne)
    try:
        api_response = api_instance.get_audit_logs(tenant_id, limit=limit, skip=skip, order=order, after=after, before=before)
        print("The response of DefaultApi->get_audit_logs:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_audit_logs: %s\n" % e)

block_from_comment_public

Parametry

Name	Type	Location	Wymagane
tenantId	string	query	Tak
commentId	string	path	Tak
sso	string	query	Nie

Odpowiedź

Zwraca: BlockFromCommentPublic200Response

Przykład

block_from_comment_public Przykład

Copy

import client
from client.models.block_from_comment_public200_response import BlockFromCommentPublic200Response
from client.models.public_block_from_comment_params import PublicBlockFromCommentParams
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    public_block_from_comment_params = client.PublicBlockFromCommentParams() # PublicBlockFromCommentParams | 
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.block_from_comment_public(tenant_id, comment_id, public_block_from_comment_params, sso=sso)
        print("The response of PublicApi->block_from_comment_public:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->block_from_comment_public: %s\n" % e)

un_block_comment_public

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Tak
commentId	string	path	Tak
sso	string	query	Nie

Odpowiedź

Zwraca: UnBlockCommentPublic200Response

Przykład

Przykład un_block_comment_public

Copy

import client
from client.models.public_block_from_comment_params import PublicBlockFromCommentParams
from client.models.un_block_comment_public200_response import UnBlockCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby zobaczyć listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    public_block_from_comment_params = client.PublicBlockFromCommentParams() # PublicBlockFromCommentParams | 
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.un_block_comment_public(tenant_id, comment_id, public_block_from_comment_params, sso=sso)
        print("The response of PublicApi->un_block_comment_public:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->un_block_comment_public: %s\n" % e)

checked_comments_for_blocked

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
commentIds	string	query	Tak	Lista identyfikatorów komentarzy oddzielonych przecinkami.
sso	string	query	Nie

Response

Zwraca: CheckedCommentsForBlocked200Response

Przykład

checked_comments_for_blocked Przykład

Copy

import client
from client.models.checked_comments_for_blocked200_response import CheckedCommentsForBlocked200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_ids = 'comment_ids_example' # str | Lista identyfikatorów komentarzy oddzielonych przecinkami.
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.checked_comments_for_blocked(tenant_id, comment_ids, sso=sso)
        print("The response of PublicApi->checked_comments_for_blocked:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->checked_comments_for_blocked: %s\n" % e)

block_user_from_comment

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
id	string	path	Tak
userId	string	query	Nie
anonUserId	string	query	Nie

Odpowiedź

Zwraca: BlockFromCommentPublic200Response

Przykład

Przykład block_user_from_comment

Copy

import client
from client.models.block_from_comment_params import BlockFromCommentParams
from client.models.block_from_comment_public200_response import BlockFromCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py dla listy wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj
# przykładu, który spełnia Twoje wymagania dotyczące uwierzytelniania.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Enter a context with an instance of the API client
with client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    block_from_comment_params = client.BlockFromCommentParams() # BlockFromCommentParams | 
    user_id = 'user_id_example' # str |  (optional)
    anon_user_id = 'anon_user_id_example' # str |  (optional)
    try:
        api_response = api_instance.block_user_from_comment(tenant_id, id, block_from_comment_params, user_id=user_id, anon_user_id=anon_user_id)
        print("The response of DefaultApi->block_user_from_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->block_user_from_comment: %s\n" % e)

create_comment_public

Parametry

Name	Type	Location	Required
tenantId	string	path	Tak
urlId	string	query	Tak
broadcastId	string	query	Tak
sessionId	string	query	Nie
sso	string	query	Nie

Odpowiedź

Zwraca: CreateCommentPublic200Response

Przykład

Przykład create_comment_public

Copy

import client
from client.models.comment_data import CommentData
from client.models.create_comment_public200_response import CreateCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Ustalenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Użyj kontekstu z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    broadcast_id = 'broadcast_id_example' # str | 
    comment_data = client.CommentData() # CommentData | 
    session_id = 'session_id_example' # str |  (opcjonalne)
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.create_comment_public(tenant_id, url_id, broadcast_id, comment_data, session_id=session_id, sso=sso)
        print("The response of PublicApi->create_comment_public:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->create_comment_public: %s\n" % e)

delete_comment

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Tak
id	string	path	Tak
contextUserId	string	query	Nie
isLive	boolean	query	Nie

Odpowiedź

Zwraca: DeleteComment200Response

Przykład

Przykład delete_comment

Copy

import client
from client.models.delete_comment200_response import DeleteComment200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ma wartość https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Przykłady dla każdej metody uwierzytelniania znajdują się poniżej, użyj tego, który
# pasuje do Twojego przypadku użycia uwierzytelniania.
# Konfiguruj uwierzytelnianie kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    context_user_id = 'context_user_id_example' # str |  (opcjonalne)
    is_live = True # bool |  (opcjonalne)
    try:
        api_response = api_instance.delete_comment(tenant_id, id, context_user_id=context_user_id, is_live=is_live)
        print("The response of DefaultApi->delete_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_comment: %s\n" % e)

delete_comment_public

Parametry

Name	Type	Location	Required
tenantId	string	path	Tak
commentId	string	path	Tak
broadcastId	string	query	Tak
editKey	string	query	Nie
sso	string	query	Nie

Odpowiedź

Zwraca: DeleteCommentPublic200Response

Przykład

Przykład delete_comment_public

Copy

import client
from client.models.delete_comment_public200_response import DeleteCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    broadcast_id = 'broadcast_id_example' # str | 
    edit_key = 'edit_key_example' # str |  (opcjonalne)
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.delete_comment_public(tenant_id, comment_id, broadcast_id, edit_key=edit_key, sso=sso)
        print("The response of PublicApi->delete_comment_public:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->delete_comment_public: %s\n" % e)

delete_comment_vote

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	path	Yes
commentId	string	path	Yes
voteId	string	path	Yes
urlId	string	query	Yes
broadcastId	string	query	Yes
editKey	string	query	No
sso	string	query	No

Odpowiedź

Zwraca: DeleteCommentVote200Response

Przykład

delete_comment_vote Przykład

Copy

import client
from client.models.delete_comment_vote200_response import DeleteCommentVote200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    vote_id = 'vote_id_example' # str | 
    url_id = 'url_id_example' # str | 
    broadcast_id = 'broadcast_id_example' # str | 
    edit_key = 'edit_key_example' # str |  (opcjonalne)
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.delete_comment_vote(tenant_id, comment_id, vote_id, url_id, broadcast_id, edit_key=edit_key, sso=sso)
        print("The response of PublicApi->delete_comment_vote:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->delete_comment_vote: %s\n" % e)

flag_comment

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Tak
id	string	path	Tak
userId	string	query	Nie
anonUserId	string	query	Nie

Odpowiedź

Zwraca: FlagComment200Response

Przykład

Przykład flag_comment

Copy

import client
from client.models.flag_comment200_response import FlagComment200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia.
# Skonfiguruj uwierzytelnianie przy użyciu klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to potrzebne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź do kontekstu z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    user_id = 'user_id_example' # str |  (opcjonalne)
    anon_user_id = 'anon_user_id_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.flag_comment(tenant_id, id, user_id=user_id, anon_user_id=anon_user_id)
        print("The response of DefaultApi->flag_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->flag_comment: %s\n" % e)

get_comment

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: GetComment200Response

Przykład

Przykład get_comment

Copy

import client
from client.models.get_comment200_response import GetComment200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py dla listy wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką zabezpieczeń serwera API.
# Przykłady dla każdej metody uwierzytelniania są podane poniżej, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Enter a context with an instance of the API client
with client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.get_comment(tenant_id, id)
        print("The response of DefaultApi->get_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_comment: %s\n" % e)

get_comment_text

Parametry

Name	Type	Location	Required
tenantId	string	ścieżka	Tak
commentId	string	ścieżka	Tak
editKey	string	zapytanie	Nie
sso	string	zapytanie	Nie

Odpowiedź

Zwraca: GetCommentText200Response

Przykład

Przykład get_comment_text

Copy

import client
from client.models.get_comment_text200_response import GetCommentText200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracyjnych.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    edit_key = 'edit_key_example' # str |  (opcjonalne)
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.get_comment_text(tenant_id, comment_id, edit_key=edit_key, sso=sso)
        print("The response of PublicApi->get_comment_text:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_comment_text: %s\n" % e)

get_comment_vote_user_names

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	path	Tak
commentId	string	path	Tak
dir	integer	query	Tak
sso	string	query	Nie

Odpowiedź

Zwraca: GetCommentVoteUserNames200Response

Przykład

get_comment_vote_user_names Przykład

Copy

import client
from client.models.get_comment_vote_user_names200_response import GetCommentVoteUserNames200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py dla listy wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    dir = 56 # int | 
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.get_comment_vote_user_names(tenant_id, comment_id, dir, sso=sso)
        print("The response of PublicApi->get_comment_vote_user_names:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_comment_vote_user_names: %s\n" % e)

get_comments

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Tak
page	integer	query	Nie
limit	integer	query	Nie
skip	integer	query	Nie
asTree	boolean	query	Nie
skipChildren	integer	query	Nie
limitChildren	integer	query	Nie
maxTreeDepth	integer	query	Nie
urlId	string	query	Nie
userId	string	query	Nie
anonUserId	string	query	Nie
contextUserId	string	query	Nie
hashTag	string	query	Nie
parentId	string	query	Nie
direction	string	query	Nie

Odpowiedź

Zwraca: GetComments200Response

Przykład

Przykład get_comments

Copy

import client
from client.models.get_comments200_response import GetComments200Response
from client.models.sort_directions import SortDirections
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Przykłady dla każdej metody uwierzytelniania znajdują się poniżej, użyj przykładu który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli jest to potrzebne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    page = 56 # int |  (opcjonalne)
    limit = 56 # int |  (opcjonalne)
    skip = 56 # int |  (opcjonalne)
    as_tree = True # bool |  (opcjonalne)
    skip_children = 56 # int |  (opcjonalne)
    limit_children = 56 # int |  (opcjonalne)
    max_tree_depth = 56 # int |  (opcjonalne)
    url_id = 'url_id_example' # str |  (opcjonalne)
    user_id = 'user_id_example' # str |  (opcjonalne)
    anon_user_id = 'anon_user_id_example' # str |  (opcjonalne)
    context_user_id = 'context_user_id_example' # str |  (opcjonalne)
    hash_tag = 'hash_tag_example' # str |  (opcjonalne)
    parent_id = 'parent_id_example' # str |  (opcjonalne)
    direction = client.SortDirections() # SortDirections |  (opcjonalne)
    try:
        api_response = api_instance.get_comments(tenant_id, page=page, limit=limit, skip=skip, as_tree=as_tree, skip_children=skip_children, limit_children=limit_children, max_tree_depth=max_tree_depth, url_id=url_id, user_id=user_id, anon_user_id=anon_user_id, context_user_id=context_user_id, hash_tag=hash_tag, parent_id=parent_id, direction=direction)
        print("The response of DefaultApi->get_comments:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_comments: %s\n" % e)

get_comments_public

żądanie tenantId urlId

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	ścieżka	Tak
urlId	string	zapytanie	Tak
page	integer	zapytanie	Nie
direction	string	zapytanie	Nie
sso	string	zapytanie	Nie
skip	integer	zapytanie	Nie
skipChildren	integer	zapytanie	Nie
limit	integer	zapytanie	Nie
limitChildren	integer	zapytanie	Nie
countChildren	boolean	zapytanie	Nie
fetchPageForCommentId	string	zapytanie	Nie
includeConfig	boolean	zapytanie	Nie
countAll	boolean	zapytanie	Nie
includei10n	boolean	zapytanie	Nie
locale	string	zapytanie	Nie
modules	string	zapytanie	Nie
isCrawler	boolean	zapytanie	Nie
includeNotificationCount	boolean	zapytanie	Nie
asTree	boolean	zapytanie	Nie
maxTreeDepth	integer	zapytanie	Nie
useFullTranslationIds	boolean	zapytanie	Nie
parentId	string	zapytanie	Nie
searchText	string	zapytanie	Nie
hashTags	array	zapytanie	Nie
userId	string	zapytanie	Nie
customConfigStr	string	zapytanie	Nie
afterCommentId	string	zapytanie	Nie
beforeCommentId	string	zapytanie	Nie

Odpowiedź

Zwraca: GetCommentsPublic200Response

Przykład

Przykład get_comments_public

Copy

import client
from client.models.get_comments_public200_response import GetCommentsPublic200Response
from client.models.sort_directions import SortDirections
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    page = 56 # int |  (opcjonalne)
    direction = client.SortDirections() # SortDirections |  (opcjonalne)
    sso = 'sso_example' # str |  (opcjonalne)
    skip = 56 # int |  (opcjonalne)
    skip_children = 56 # int |  (opcjonalne)
    limit = 56 # int |  (opcjonalne)
    limit_children = 56 # int |  (opcjonalne)
    count_children = True # bool |  (opcjonalne)
    fetch_page_for_comment_id = 'fetch_page_for_comment_id_example' # str |  (opcjonalne)
    include_config = True # bool |  (opcjonalne)
    count_all = True # bool |  (opcjonalne)
    includei10n = True # bool |  (opcjonalne)
    locale = 'locale_example' # str |  (opcjonalne)
    modules = 'modules_example' # str |  (opcjonalne)
    is_crawler = True # bool |  (opcjonalne)
    include_notification_count = True # bool |  (opcjonalne)
    as_tree = True # bool |  (opcjonalne)
    max_tree_depth = 56 # int |  (opcjonalne)
    use_full_translation_ids = True # bool |  (opcjonalne)
    parent_id = 'parent_id_example' # str |  (opcjonalne)
    search_text = 'search_text_example' # str |  (opcjonalne)
    hash_tags = ['hash_tags_example'] # List[str] |  (opcjonalne)
    user_id = 'user_id_example' # str |  (opcjonalne)
    custom_config_str = 'custom_config_str_example' # str |  (opcjonalne)
    after_comment_id = 'after_comment_id_example' # str |  (opcjonalne)
    before_comment_id = 'before_comment_id_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.get_comments_public(tenant_id, url_id, page=page, direction=direction, sso=sso, skip=skip, skip_children=skip_children, limit=limit, limit_children=limit_children, count_children=count_children, fetch_page_for_comment_id=fetch_page_for_comment_id, include_config=include_config, count_all=count_all, includei10n=includei10n, locale=locale, modules=modules, is_crawler=is_crawler, include_notification_count=include_notification_count, as_tree=as_tree, max_tree_depth=max_tree_depth, use_full_translation_ids=use_full_translation_ids, parent_id=parent_id, search_text=search_text, hash_tags=hash_tags, user_id=user_id, custom_config_str=custom_config_str, after_comment_id=after_comment_id, before_comment_id=before_comment_id)
        print("The response of PublicApi->get_comments_public:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_comments_public: %s\n" % e)

lock_comment

Parametry

Name	Type	Location	Required
tenantId	string	path	Tak
commentId	string	path	Tak
broadcastId	string	query	Tak
sso	string	query	Nie

Odpowiedź

Zwraca: LockComment200Response

Przykład

Przykład lock_comment

Copy

import client
from client.models.lock_comment200_response import LockComment200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    broadcast_id = 'broadcast_id_example' # str | 
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.lock_comment(tenant_id, comment_id, broadcast_id, sso=sso)
        print("The response of PublicApi->lock_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->lock_comment: %s\n" % e)

pin_comment

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	ścieżka	Tak
commentId	string	ścieżka	Tak
broadcastId	string	zapytanie	Tak
sso	string	zapytanie	Nie

Odpowiedź

Zwraca: PinComment200Response

Przykład

Przykład pin_comment

Copy

import client
from client.models.pin_comment200_response import PinComment200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    broadcast_id = 'broadcast_id_example' # str | 
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.pin_comment(tenant_id, comment_id, broadcast_id, sso=sso)
        print("The response of PublicApi->pin_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->pin_comment: %s\n" % e)

save_comment

Parametry

Name	Type	Location	Required
tenantId	`string`	Lokalizacja	Tak
isLive	`boolean`	Lokalizacja	Nie
doSpamCheck	`boolean`	Lokalizacja	Nie
sendEmails	`boolean`	Lokalizacja	Nie
populateNotifications	`boolean`	Lokalizacja	Nie

Odpowiedź

Zwraca: SaveComment200Response

Przykład

Przykład save_comment

Copy

import client
from client.models.create_comment_params import CreateCommentParams
from client.models.save_comment200_response import SaveComment200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania; użyj przykładu, który
# spełnia Twoje wymagania dotyczące uwierzytelniania.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    create_comment_params = client.CreateCommentParams() # CreateCommentParams | 
    is_live = True # bool |  (optional)
    do_spam_check = True # bool |  (optional)
    send_emails = True # bool |  (optional)
    populate_notifications = True # bool |  (optional)
    try:
        api_response = api_instance.save_comment(tenant_id, create_comment_params, is_live=is_live, do_spam_check=do_spam_check, send_emails=send_emails, populate_notifications=populate_notifications)
        print("The response of DefaultApi->save_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->save_comment: %s\n" % e)

save_comments_bulk

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
isLive	boolean	query	Nie
doSpamCheck	boolean	query	Nie
sendEmails	boolean	query	Nie
populateNotifications	boolean	query	Nie

Odpowiedź

Zwraca: SaveComment200Response

Przykład

Przykład save_comments_bulk

Copy

import client
from client.models.create_comment_params import CreateCommentParams
from client.models.save_comment200_response import SaveComment200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Przykłady dla każdej metody uwierzytelniania podane są poniżej, użyj przykładu, który
# pasuje do Twojego przypadku użycia uwierzytelniania.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    create_comment_params = [client.CreateCommentParams()] # List[CreateCommentParams] | 
    is_live = True # bool |  (opcjonalne)
    do_spam_check = True # bool |  (opcjonalne)
    send_emails = True # bool |  (opcjonalne)
    populate_notifications = True # bool |  (opcjonalne)
    try:
        api_response = api_instance.save_comments_bulk(tenant_id, create_comment_params, is_live=is_live, do_spam_check=do_spam_check, send_emails=send_emails, populate_notifications=populate_notifications)
        print("The response of DefaultApi->save_comments_bulk:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->save_comments_bulk: %s\n" % e)

set_comment_text

Parametry

Name	Type	Location	Required
tenantId	string	path	Tak
commentId	string	path	Tak
broadcastId	string	query	Tak
editKey	string	query	Nie
sso	string	query	Nie

Odpowiedź

Zwraca: SetCommentText200Response

Przykład

Przykład użycia set_comment_text

Copy

import client
from client.models.comment_text_update_request import CommentTextUpdateRequest
from client.models.set_comment_text200_response import SetCommentText200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby zobaczyć listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    broadcast_id = 'broadcast_id_example' # str | 
    comment_text_update_request = client.CommentTextUpdateRequest() # CommentTextUpdateRequest | 
    edit_key = 'edit_key_example' # str |  (opcjonalne)
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.set_comment_text(tenant_id, comment_id, broadcast_id, comment_text_update_request, edit_key=edit_key, sso=sso)
        print("The response of PublicApi->set_comment_text:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->set_comment_text: %s\n" % e)

un_block_user_from_comment

Parametry

Name	Type	Lokalizacja	Wymagane
tenantId	string	zapytanie	Tak
id	string	ścieżka	Tak
userId	string	zapytanie	Nie
anonUserId	string	zapytanie	Nie

Odpowiedź

Zwraca: UnBlockCommentPublic200Response

Przykład

Przykład un_block_user_from_comment

Copy

import client
from client.models.un_block_comment_public200_response import UnBlockCommentPublic200Response
from client.models.un_block_from_comment_params import UnBlockFromCommentParams
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu który
# spełnia Twój przypadek użycia uwierzytelniania.
# Skonfiguruj autoryzację klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli jest potrzebny
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    un_block_from_comment_params = client.UnBlockFromCommentParams() # UnBlockFromCommentParams | 
    user_id = 'user_id_example' # str |  (opcjonalne)
    anon_user_id = 'anon_user_id_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.un_block_user_from_comment(tenant_id, id, un_block_from_comment_params, user_id=user_id, anon_user_id=anon_user_id)
        print("The response of DefaultApi->un_block_user_from_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->un_block_user_from_comment: %s\n" % e)

un_flag_comment

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
id	string	path	Tak
userId	string	query	Nie
anonUserId	string	query	Nie

Odpowiedź

Zwraca: FlagComment200Response

Przykład

Przykład un_flag_comment

Copy

import client
from client.models.flag_comment200_response import FlagComment200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py dla listy wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# spełnia Twój przypadek użycia uwierzytelniania.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź do kontekstu z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    user_id = 'user_id_example' # str |  (opcjonalne)
    anon_user_id = 'anon_user_id_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.un_flag_comment(tenant_id, id, user_id=user_id, anon_user_id=anon_user_id)
        print("The response of DefaultApi->un_flag_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->un_flag_comment: %s\n" % e)

un_lock_comment

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	path	Tak
commentId	string	path	Tak
broadcastId	string	query	Tak
sso	string	query	Nie

Odpowiedź

Zwraca: LockComment200Response

Przykład

Przykład un_lock_comment

Copy

import client
from client.models.lock_comment200_response import LockComment200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    broadcast_id = 'broadcast_id_example' # str | 
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.un_lock_comment(tenant_id, comment_id, broadcast_id, sso=sso)
        print("The response of PublicApi->un_lock_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->un_lock_comment: %s\n" % e)

un_pin_comment

Parametry

Name	Type	Location	Required
tenantId	string	path	Tak
commentId	string	path	Tak
broadcastId	string	query	Tak
sso	string	query	Nie

Odpowiedź

Zwraca: PinComment200Response

Przykład

Przykład un_pin_comment

Copy

import client
from client.models.pin_comment200_response import PinComment200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Użyj kontekstu z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    broadcast_id = 'broadcast_id_example' # str | 
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.un_pin_comment(tenant_id, comment_id, broadcast_id, sso=sso)
        print("The response of PublicApi->un_pin_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->un_pin_comment: %s\n" % e)

update_comment

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
id	string	path	Tak
contextUserId	string	query	Nie
doSpamCheck	boolean	query	Nie
isLive	boolean	query	Nie

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład update_comment

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.models.pick_api_comment_updatable_comment_fields import PickAPICommentUpdatableCommentFields
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Przykłady dla każdej metody uwierzytelniania są podane poniżej — użyj tego,
# który odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to potrzebne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    body = client.PickAPICommentUpdatableCommentFields() # PickAPICommentUpdatableCommentFields | 
    context_user_id = 'context_user_id_example' # str |  (opcjonalne)
    do_spam_check = True # bool |  (opcjonalne)
    is_live = True # bool |  (opcjonalne)
    try:
        api_response = api_instance.update_comment(tenant_id, id, body, context_user_id=context_user_id, do_spam_check=do_spam_check, is_live=is_live)
        print("The response of DefaultApi->update_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->update_comment: %s\n" % e)

vote_comment

Parametry

Name	Type	Location	Required
tenantId	string	path	Yes
commentId	string	path	Yes
urlId	string	query	Yes
broadcastId	string	query	Yes
sessionId	string	query	No
sso	string	query	No

Odpowiedź

Zwraca: VoteComment200Response

Przykład

Przykład vote_comment

Copy

import client
from client.models.vote_body_params import VoteBodyParams
from client.models.vote_comment200_response import VoteComment200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    url_id = 'url_id_example' # str | 
    broadcast_id = 'broadcast_id_example' # str | 
    vote_body_params = client.VoteBodyParams() # VoteBodyParams | 
    session_id = 'session_id_example' # str |  (opcjonalne)
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.vote_comment(tenant_id, comment_id, url_id, broadcast_id, vote_body_params, session_id=session_id, sso=sso)
        print("The response of PublicApi->vote_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->vote_comment: %s\n" % e)

add_domain_config

Parameters

Name	Type	Location	Required	Description
tenantId	string	query	Tak

Response

Zwraca: AddDomainConfig200Response

Przykład

Przykład add_domain_config

Copy

import client
from client.models.add_domain_config200_response import AddDomainConfig200Response
from client.models.add_domain_config_params import AddDomainConfigParams
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką zabezpieczeń serwera API.
# Przykłady dla każdej metody uwierzytelniania są podane poniżej. Użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to potrzebne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    add_domain_config_params = client.AddDomainConfigParams() # AddDomainConfigParams | 
    try:
        api_response = api_instance.add_domain_config(tenant_id, add_domain_config_params)
        print("The response of DefaultApi->add_domain_config:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->add_domain_config: %s\n" % e)

delete_domain_config

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Yes
domain	string	path	Yes

Odpowiedź

Zwraca: DeleteDomainConfig200Response

Przykład

Przykład delete_domain_config

Copy

import client
from client.models.delete_domain_config200_response import DeleteDomainConfig200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby poznać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu,
# który odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj uwierzytelnianie kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzebne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    domain = 'domain_example' # str | 
    try:
        api_response = api_instance.delete_domain_config(tenant_id, domain)
        print("The response of DefaultApi->delete_domain_config:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_domain_config: %s\n" % e)

get_domain_config

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
domain	string	path	Tak

Odpowiedź

Zwraca: GetDomainConfig200Response

Przykład

Przykład get_domain_config

Copy

import client
from client.models.get_domain_config200_response import GetDomainConfig200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania — użyj tego,
# który spełnia Twoje potrzeby uwierzytelniania.
# Konfiguracja autoryzacji kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    domain = 'domain_example' # str | 
    try:
        api_response = api_instance.get_domain_config(tenant_id, domain)
        print("The response of DefaultApi->get_domain_config:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_domain_config: %s\n" % e)

get_domain_configs

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak

Odpowiedź

Zwraca: GetDomainConfigs200Response

Przykład

Przykład get_domain_configs

Copy

import client
from client.models.get_domain_configs200_response import GetDomainConfigs200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj
# tego, który odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj uwierzytelnianie kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    try:
        api_response = api_instance.get_domain_configs(tenant_id)
        print("The response of DefaultApi->get_domain_configs:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_domain_configs: %s\n" % e)

patch_domain_config

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
domainToUpdate	string	path	Tak

Odpowiedź

Zwraca: GetDomainConfig200Response

Przykład

Przykład patch_domain_config

Copy

import client
from client.models.get_domain_config200_response import GetDomainConfig200Response
from client.models.patch_domain_config_params import PatchDomainConfigParams
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    domain_to_update = 'domain_to_update_example' # str | 
    patch_domain_config_params = client.PatchDomainConfigParams() # PatchDomainConfigParams | 
    try:
        api_response = api_instance.patch_domain_config(tenant_id, domain_to_update, patch_domain_config_params)
        print("The response of DefaultApi->patch_domain_config:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->patch_domain_config: %s\n" % e)

put_domain_config

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
domainToUpdate	string	path	Tak

Odpowiedź

Zwraca: GetDomainConfig200Response

Przykład

Przykład put_domain_config

Copy

import client
from client.models.get_domain_config200_response import GetDomainConfig200Response
from client.models.update_domain_config_params import UpdateDomainConfigParams
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację za pomocą klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    domain_to_update = 'domain_to_update_example' # str | 
    update_domain_config_params = client.UpdateDomainConfigParams() # UpdateDomainConfigParams | 
    try:
        api_response = api_instance.put_domain_config(tenant_id, domain_to_update, update_domain_config_params)
        print("The response of DefaultApi->put_domain_config:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->put_domain_config: %s\n" % e)

create_email_template

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak

Odpowiedź

Zwraca: CreateEmailTemplate200Response

Przykład

Przykład create_email_template

Copy

import client
from client.models.create_email_template200_response import CreateEmailTemplate200Response
from client.models.create_email_template_body import CreateEmailTemplateBody
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką zabezpieczeń serwera API.
# Poniżej zamieszczono przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Konfiguracja autoryzacji kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli jest potrzebny
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    create_email_template_body = client.CreateEmailTemplateBody() # CreateEmailTemplateBody | 
    try:
        api_response = api_instance.create_email_template(tenant_id, create_email_template_body)
        print("The response of DefaultApi->create_email_template:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->create_email_template: %s\n" % e)

delete_email_template

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

delete_email_template Przykład

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania; użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniższe, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.delete_email_template(tenant_id, id)
        print("The response of DefaultApi->delete_email_template:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_email_template: %s\n" % e)

delete_email_template_render_error

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Tak
id	string	path	Tak
errorId	string	path	Tak

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład delete_email_template_render_error

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Przykłady dla każdej metody uwierzytelniania są podane poniżej, użyj przykładu który
# spełnia wymagania twojego przypadku użycia uwierzytelniania.
# Skonfiguruj uwierzytelnianie kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    error_id = 'error_id_example' # str | 
    try:
        api_response = api_instance.delete_email_template_render_error(tenant_id, id, error_id)
        print("The response of DefaultApi->delete_email_template_render_error:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_email_template_render_error: %s\n" % e)

get_email_template

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: GetEmailTemplate200Response

Przykład

Przykład get_email_template

Copy

import client
from client.models.get_email_template200_response import GetEmailTemplate200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania — użyj tego,
# który pasuje do Twojego przypadku użycia.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzeba
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.get_email_template(tenant_id, id)
        print("The response of DefaultApi->get_email_template:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_email_template: %s\n" % e)

get_email_template_definitions

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak

Odpowiedź

Zwraca: GetEmailTemplateDefinitions200Response

Przykład

Przykład get_email_template_definitions

Copy

import client
from client.models.get_email_template_definitions200_response import GetEmailTemplateDefinitions200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    try:
        api_response = api_instance.get_email_template_definitions(tenant_id)
        print("The response of DefaultApi->get_email_template_definitions:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_email_template_definitions: %s\n" % e)

get_email_template_render_errors

Parametry

Name	Type	Location	Required
tenantId	string	query	Yes
id	string	path	Yes
skip	number	query	No

Odpowiedź

Zwraca: GetEmailTemplateRenderErrors200Response

Przykład

Przykład get_email_template_render_errors

Copy

import client
from client.models.get_email_template_render_errors200_response import GetEmailTemplateRenderErrors200Response
from client.rest import ApiException
from pprint import pprint
# Definiowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Przykłady dla każdej metody uwierzytelniania są podane poniżej, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    skip = 3.4 # float |  (optional)
    try:
        api_response = api_instance.get_email_template_render_errors(tenant_id, id, skip=skip)
        print("The response of DefaultApi->get_email_template_render_errors:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_email_template_render_errors: %s\n" % e)

get_email_templates

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
skip	number	query	Nie

Odpowiedź

Zwraca: GetEmailTemplates200Response

Przykład

Przykład get_email_templates

Copy

import client
from client.models.get_email_templates200_response import GetEmailTemplates200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką zabezpieczeń serwera API.
# Przykłady dla każdej metody uwierzytelniania znajdują się poniżej, użyj przykładu który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 3.4 # float |  (optional)
    try:
        api_response = api_instance.get_email_templates(tenant_id, skip=skip)
        print("The response of DefaultApi->get_email_templates:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_email_templates: %s\n" % e)

render_email_template

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
locale	string	query	Nie

Odpowiedź

Zwraca: RenderEmailTemplate200Response

Przykład

Przykład render_email_template

Copy

import client
from client.models.render_email_template200_response import RenderEmailTemplate200Response
from client.models.render_email_template_body import RenderEmailTemplateBody
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką zabezpieczeń serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia.
# Skonfiguruj autoryzację za pomocą klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    render_email_template_body = client.RenderEmailTemplateBody() # RenderEmailTemplateBody | 
    locale = 'locale_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.render_email_template(tenant_id, render_email_template_body, locale=locale)
        print("The response of DefaultApi->render_email_template:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->render_email_template: %s\n" % e)

update_email_template

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Yes
id	string	path	Yes

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład update_email_template

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.models.update_email_template_body import UpdateEmailTemplateBody
from client.rest import ApiException
from pprint import pprint
# Definiowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    update_email_template_body = client.UpdateEmailTemplateBody() # UpdateEmailTemplateBody | 
    try:
        api_response = api_instance.update_email_template(tenant_id, id, update_email_template_body)
        print("The response of DefaultApi->update_email_template:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->update_email_template: %s\n" % e)

get_event_log

req tenantId urlId userIdWS

Parametry

Name	Type	Location	Required
tenantId	string	ścieżka	Tak
urlId	string	zapytanie	Tak
userIdWS	string	zapytanie	Tak
startTime	integer	zapytanie	Tak
endTime	integer	zapytanie	Tak

Odpowiedź

Zwraca: GetEventLog200Response

Przykład

Przykład get_event_log

Copy

import client
from client.models.get_event_log200_response import GetEventLog200Response
from client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://fastcomments.com
# See configuration.py for a list of all supported configuration parameters.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Enter a context with an instance of the API client
with client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    user_id_ws = 'user_id_ws_example' # str | 
    start_time = 56 # int | 
    end_time = 56 # int | 
    try:
        api_response = api_instance.get_event_log(tenant_id, url_id, user_id_ws, start_time, end_time)
        print("The response of PublicApi->get_event_log:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_event_log: %s\n" % e)

get_global_event_log

req tenantId urlId userIdWS

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	path	Tak
urlId	string	query	Tak
userIdWS	string	query	Tak
startTime	integer	query	Tak
endTime	integer	query	Tak

Odpowiedź

Zwraca: GetEventLog200Response

Przykład

Przykład get_global_event_log

Copy

import client
from client.models.get_event_log200_response import GetEventLog200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    user_id_ws = 'user_id_ws_example' # str | 
    start_time = 56 # int | 
    end_time = 56 # int | 
    try:
        api_response = api_instance.get_global_event_log(tenant_id, url_id, user_id_ws, start_time, end_time)
        print("The response of PublicApi->get_global_event_log:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_global_event_log: %s\n" % e)

create_feed_post

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
broadcastId	string	query	Nie
isLive	boolean	query	Nie
doSpamCheck	boolean	query	Nie
skipDupCheck	boolean	query	Nie

Odpowiedź

Zwraca: CreateFeedPost200Response

Przykład

Przykład create_feed_post

Copy

import client
from client.models.create_feed_post200_response import CreateFeedPost200Response
from client.models.create_feed_post_params import CreateFeedPostParams
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    create_feed_post_params = client.CreateFeedPostParams() # CreateFeedPostParams | 
    broadcast_id = 'broadcast_id_example' # str |  (opcjonalne)
    is_live = True # bool |  (opcjonalne)
    do_spam_check = True # bool |  (opcjonalne)
    skip_dup_check = True # bool |  (opcjonalne)
    try:
        api_response = api_instance.create_feed_post(tenant_id, create_feed_post_params, broadcast_id=broadcast_id, is_live=is_live, do_spam_check=do_spam_check, skip_dup_check=skip_dup_check)
        print("The response of DefaultApi->create_feed_post:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->create_feed_post: %s\n" % e)

create_feed_post_public

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	path	Yes
broadcastId	string	query	No
sso	string	query	No

Odpowiedź

Zwraca: CreateFeedPostPublic200Response

Przykład

Przykład create_feed_post_public

Copy

import client
from client.models.create_feed_post_params import CreateFeedPostParams
from client.models.create_feed_post_public200_response import CreateFeedPostPublic200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    create_feed_post_params = client.CreateFeedPostParams() # CreateFeedPostParams | 
    broadcast_id = 'broadcast_id_example' # str |  (opcjonalne)
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.create_feed_post_public(tenant_id, create_feed_post_params, broadcast_id=broadcast_id, sso=sso)
        print("The response of PublicApi->create_feed_post_public:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->create_feed_post_public: %s\n" % e)

delete_feed_post_public

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	path	Tak
postId	string	path	Tak
broadcastId	string	query	Nie
sso	string	query	Nie

Odpowiedź

Zwraca: DeleteFeedPostPublic200Response

Przykład

Przykład delete_feed_post_public

Copy

import client
from client.models.delete_feed_post_public200_response import DeleteFeedPostPublic200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    post_id = 'post_id_example' # str | 
    broadcast_id = 'broadcast_id_example' # str |  (opcjonalne)
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.delete_feed_post_public(tenant_id, post_id, broadcast_id=broadcast_id, sso=sso)
        print("The response of PublicApi->delete_feed_post_public:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->delete_feed_post_public: %s\n" % e)

get_feed_posts

req tenantId afterId

Parametry

Name	Type	Location	Wymagane
tenantId	string	query	Tak
afterId	string	query	Nie
limit	integer	query	Nie
tags	array	query	Nie

Odpowiedź

Zwraca: GetFeedPosts200Response

Przykład

Przykład get_feed_posts

Copy

import client
from client.models.get_feed_posts200_response import GetFeedPosts200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Konfiguracja autoryzacji za pomocą klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    after_id = 'after_id_example' # str |  (optional)
    limit = 56 # int |  (optional)
    tags = ['tags_example'] # List[str] |  (optional)
    try:
        api_response = api_instance.get_feed_posts(tenant_id, after_id=after_id, limit=limit, tags=tags)
        print("The response of DefaultApi->get_feed_posts:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_feed_posts: %s\n" % e)

get_feed_posts_public

req tenantId afterId

Parametry

Name	Type	Location	Required
tenantId	string	path	Tak
afterId	string	query	Nie
limit	integer	query	Nie
tags	array	query	Nie
sso	string	query	Nie
isCrawler	boolean	query	Nie
includeUserInfo	boolean	query	Nie

Odpowiedź

Zwraca: GetFeedPostsPublic200Response

Przykład

Przykład get_feed_posts_public

Copy

import client
from client.models.get_feed_posts_public200_response import GetFeedPostsPublic200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    after_id = 'after_id_example' # str |  (opcjonalne)
    limit = 56 # int |  (opcjonalne)
    tags = ['tags_example'] # List[str] |  (opcjonalne)
    sso = 'sso_example' # str |  (opcjonalne)
    is_crawler = True # bool |  (opcjonalne)
    include_user_info = True # bool |  (opcjonalne)
    try:
        api_response = api_instance.get_feed_posts_public(tenant_id, after_id=after_id, limit=limit, tags=tags, sso=sso, is_crawler=is_crawler, include_user_info=include_user_info)
        print("The response of PublicApi->get_feed_posts_public:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_feed_posts_public: %s\n" % e)

get_feed_posts_stats

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	path	Tak
postIds	array	query	Tak
sso	string	query	Nie

Odpowiedź

Zwraca: GetFeedPostsStats200Response

Przykład

Przykład get_feed_posts_stats

Copy

import client
from client.models.get_feed_posts_stats200_response import GetFeedPostsStats200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    post_ids = ['post_ids_example'] # List[str] | 
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.get_feed_posts_stats(tenant_id, post_ids, sso=sso)
        print("The response of PublicApi->get_feed_posts_stats:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_feed_posts_stats: %s\n" % e)

get_user_reacts_public

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	path	Tak
postIds	array	query	Nie
sso	string	query	Nie

Odpowiedź

Zwraca: GetUserReactsPublic200Response

Przykład

Przykład get_user_reacts_public

Copy

import client
from client.models.get_user_reacts_public200_response import GetUserReactsPublic200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    post_ids = ['post_ids_example'] # List[str] |  (opcjonalne)
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.get_user_reacts_public(tenant_id, post_ids=post_ids, sso=sso)
        print("The response of PublicApi->get_user_reacts_public:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_user_reacts_public: %s\n" % e)

react_feed_post_public

Parametry

Name	Type	Location	Required
tenantId	string	path	Tak
postId	string	path	Tak
isUndo	boolean	query	Nie
broadcastId	string	query	Nie
sso	string	query	Nie

Odpowiedź

Zwraca: ReactFeedPostPublic200Response

Przykład

Przykład react_feed_post_public

Copy

import client
from client.models.react_body_params import ReactBodyParams
from client.models.react_feed_post_public200_response import ReactFeedPostPublic200Response
from client.rest import ApiException
from pprint import pprint
# Ustalenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    post_id = 'post_id_example' # str | 
    react_body_params = client.ReactBodyParams() # ReactBodyParams | 
    is_undo = True # bool |  (opcjonalne)
    broadcast_id = 'broadcast_id_example' # str |  (opcjonalne)
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.react_feed_post_public(tenant_id, post_id, react_body_params, is_undo=is_undo, broadcast_id=broadcast_id, sso=sso)
        print("The response of PublicApi->react_feed_post_public:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->react_feed_post_public: %s\n" % e)

update_feed_post

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład update_feed_post

Copy

import client
from client.models.feed_post import FeedPost
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z zasadami bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania — użyj przykładu,
# który odpowiada Twojemu przypadkowi użycia.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    feed_post = client.FeedPost() # FeedPost | 
    try:
        api_response = api_instance.update_feed_post(tenant_id, id, feed_post)
        print("The response of DefaultApi->update_feed_post:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->update_feed_post: %s\n" % e)

update_feed_post_public

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	path	Tak
postId	string	path	Tak
broadcastId	string	query	Nie
sso	string	query	Nie

Odpowiedź

Zwraca: CreateFeedPostPublic200Response

Przykład

Przykład update_feed_post_public

Copy

import client
from client.models.create_feed_post_public200_response import CreateFeedPostPublic200Response
from client.models.update_feed_post_params import UpdateFeedPostParams
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    post_id = 'post_id_example' # str | 
    update_feed_post_params = client.UpdateFeedPostParams() # UpdateFeedPostParams | 
    broadcast_id = 'broadcast_id_example' # str |  (opcjonalne)
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.update_feed_post_public(tenant_id, post_id, update_feed_post_params, broadcast_id=broadcast_id, sso=sso)
        print("The response of PublicApi->update_feed_post_public:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->update_feed_post_public: %s\n" % e)

flag_comment_public

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
commentId	string	path	Tak
isFlagged	boolean	query	Tak
sso	string	query	Nie

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład flag_comment_public

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    is_flagged = True # bool | 
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.flag_comment_public(tenant_id, comment_id, is_flagged, sso=sso)
        print("The response of PublicApi->flag_comment_public:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->flag_comment_public: %s\n" % e)

add_hash_tag

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Nie

Odpowiedź

Zwraca: AddHashTag200Response

Przykład

Przykład add_hash_tag

Copy

import client
from client.models.add_hash_tag200_response import AddHashTag200Response
from client.models.create_hash_tag_body import CreateHashTagBody
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj tego przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj uwierzytelnianie kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str |  (opcjonalne)
    create_hash_tag_body = client.CreateHashTagBody() # CreateHashTagBody |  (opcjonalne)
    try:
        api_response = api_instance.add_hash_tag(tenant_id=tenant_id, create_hash_tag_body=create_hash_tag_body)
        print("The response of DefaultApi->add_hash_tag:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->add_hash_tag: %s\n" % e)

add_hash_tags_bulk

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Nie

Odpowiedź

Zwraca: AddHashTagsBulk200Response

Przykład

Przykład add_hash_tags_bulk

Copy

import client
from client.models.add_hash_tags_bulk200_response import AddHashTagsBulk200Response
from client.models.bulk_create_hash_tags_body import BulkCreateHashTagsBody
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką zabezpieczeń serwera API.
# Przykłady dla każdej metody uwierzytelniania są podane poniżej, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str |  (opcjonalne)
    bulk_create_hash_tags_body = client.BulkCreateHashTagsBody() # BulkCreateHashTagsBody |  (opcjonalne)
    try:
        api_response = api_instance.add_hash_tags_bulk(tenant_id=tenant_id, bulk_create_hash_tags_body=bulk_create_hash_tags_body)
        print("The response of DefaultApi->add_hash_tags_bulk:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->add_hash_tags_bulk: %s\n" % e)

delete_hash_tag

Parametry

Name	Type	Location	Required	Description
tag	string	ścieżka	Yes
tenantId	string	query	No

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład delete_hash_tag

Copy

import client
from client.models.delete_hash_tag_request import DeleteHashTagRequest
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody autoryzacji, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tag = 'tag_example' # str | 
    tenant_id = 'tenant_id_example' # str |  (opcjonalne)
    delete_hash_tag_request = client.DeleteHashTagRequest() # DeleteHashTagRequest |  (opcjonalne)
    try:
        api_response = api_instance.delete_hash_tag(tag, tenant_id=tenant_id, delete_hash_tag_request=delete_hash_tag_request)
        print("The response of DefaultApi->delete_hash_tag:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_hash_tag: %s\n" % e)

get_hash_tags

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
page	number	query	Nie

Odpowiedź

Zwraca: GetHashTags200Response

Przykład

Przykład get_hash_tags

Copy

import client
from client.models.get_hash_tags200_response import GetHashTags200Response
from client.rest import ApiException
from pprint import pprint
# Definiowanie hosta jest opcjonalne i domyślnie ustawia się na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    page = 3.4 # float |  (opcjonalne)
    try:
        api_response = api_instance.get_hash_tags(tenant_id, page=page)
        print("The response of DefaultApi->get_hash_tags:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_hash_tags: %s\n" % e)

patch_hash_tag

Parametry

Name	Type	Location	Required	Description
tag	string	path	Tak
tenantId	string	query	Nie

Odpowiedź

Zwraca: PatchHashTag200Response

Przykład

Przykład patch_hash_tag

Copy

import client
from client.models.patch_hash_tag200_response import PatchHashTag200Response
from client.models.update_hash_tag_body import UpdateHashTagBody
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby zobaczyć listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia.
# Skonfiguruj uwierzytelnianie kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tag = 'tag_example' # str | 
    tenant_id = 'tenant_id_example' # str |  (opcjonalny)
    update_hash_tag_body = client.UpdateHashTagBody() # UpdateHashTagBody |  (opcjonalny)
    try:
        api_response = api_instance.patch_hash_tag(tag, tenant_id=tenant_id, update_hash_tag_body=update_hash_tag_body)
        print("The response of DefaultApi->patch_hash_tag:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->patch_hash_tag: %s\n" % e)

create_moderator

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	zapytanie	Tak

Odpowiedź

Zwraca: CreateModerator200Response

Przykład

Przykład create_moderator

Copy

import client
from client.models.create_moderator200_response import CreateModerator200Response
from client.models.create_moderator_body import CreateModeratorBody
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania; użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Konfiguracja autoryzacji kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    create_moderator_body = client.CreateModeratorBody() # CreateModeratorBody | 
    try:
        api_response = api_instance.create_moderator(tenant_id, create_moderator_body)
        print("The response of DefaultApi->create_moderator:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->create_moderator: %s\n" % e)

delete_moderator

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Yes
id	string	path	Yes
sendEmail	string	query	No

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład delete_moderator

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://fastcomments.com
# See configuration.py for a list of all supported configuration parameters.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Enter a context with an instance of the API client
with client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    send_email = 'send_email_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.delete_moderator(tenant_id, id, send_email=send_email)
        print("The response of DefaultApi->delete_moderator:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_moderator: %s\n" % e)

get_moderator

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: GetModerator200Response

Przykład

Przykład get_moderator

Copy

import client
from client.models.get_moderator200_response import GetModerator200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu który
# odpowiada Twojemu przypadkowi użycia.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to potrzebne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.get_moderator(tenant_id, id)
        print("The response of DefaultApi->get_moderator:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_moderator: %s\n" % e)

get_moderators

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
skip	number	query	Nie

Odpowiedź

Zwraca: GetModerators200Response

Przykład

Przykład get_moderators

Copy

import client
from client.models.get_moderators200_response import GetModerators200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Przykłady dla każdej metody uwierzytelniania znajdują się poniżej, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj uwierzytelnianie kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 3.4 # float |  (opcjonalne)
    try:
        api_response = api_instance.get_moderators(tenant_id, skip=skip)
        print("The response of DefaultApi->get_moderators:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_moderators: %s\n" % e)

send_invite

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
id	string	path	Tak
fromName	string	query	Tak

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład send_invite

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracyjnych.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania — użyj tego,
# który odpowiada Twojemu przypadkowi użycia.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzeba
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    from_name = 'from_name_example' # str | 
    try:
        api_response = api_instance.send_invite(tenant_id, id, from_name)
        print("The response of DefaultApi->send_invite:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->send_invite: %s\n" % e)

update_moderator

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład update_moderator

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.models.update_moderator_body import UpdateModeratorBody
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania; użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    update_moderator_body = client.UpdateModeratorBody() # UpdateModeratorBody | 
    try:
        api_response = api_instance.update_moderator(tenant_id, id, update_moderator_body)
        print("The response of DefaultApi->update_moderator:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->update_moderator: %s\n" % e)

delete_notification_count

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład delete_notification_count

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzeba
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.delete_notification_count(tenant_id, id)
        print("The response of DefaultApi->delete_notification_count:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_notification_count: %s\n" % e)

get_cached_notification_count

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: GetCachedNotificationCount200Response

Przykład

Przykład get_cached_notification_count

Copy

import client
from client.models.get_cached_notification_count200_response import GetCachedNotificationCount200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Konfiguracja autoryzacji kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzeba
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.get_cached_notification_count(tenant_id, id)
        print("The response of DefaultApi->get_cached_notification_count:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_cached_notification_count: %s\n" % e)

get_notification_count

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Tak
userId	string	query	Nie
urlId	string	query	Nie
fromCommentId	string	query	Nie
viewed	boolean	query	Nie
type	string	query	Nie

Odpowiedź

Zwraca: GetNotificationCount200Response

Przykład

Przykład get_notification_count

Copy

import client
from client.models.get_notification_count200_response import GetNotificationCount200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania — użyj tego, który
# odpowiada Twojemu przypadkowi użycia.
# Konfiguracja autoryzacji kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (opcjonalne)
    url_id = 'url_id_example' # str |  (opcjonalne)
    from_comment_id = 'from_comment_id_example' # str |  (opcjonalne)
    viewed = True # bool |  (opcjonalne)
    type = 'type_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.get_notification_count(tenant_id, user_id=user_id, url_id=url_id, from_comment_id=from_comment_id, viewed=viewed, type=type)
        print("The response of DefaultApi->get_notification_count:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_notification_count: %s\n" % e)

get_notifications

Parametry

Name	Type	Location	Required
tenantId	string	query	Yes
userId	string	query	No
urlId	string	query	No
fromCommentId	string	query	No
viewed	boolean	query	No
type	string	query	No
skip	number	query	No

Odpowiedź

Zwraca: GetNotifications200Response

Przykład

Przykład get_notifications

Copy

import client
from client.models.get_notifications200_response import GetNotifications200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację za pomocą klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (optional)
    url_id = 'url_id_example' # str |  (optional)
    from_comment_id = 'from_comment_id_example' # str |  (optional)
    viewed = True # bool |  (optional)
    type = 'type_example' # str |  (optional)
    skip = 3.4 # float |  (optional)
    try:
        api_response = api_instance.get_notifications(tenant_id, user_id=user_id, url_id=url_id, from_comment_id=from_comment_id, viewed=viewed, type=type, skip=skip)
        print("The response of DefaultApi->get_notifications:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_notifications: %s\n" % e)

update_notification

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Tak
id	string	path	Tak
userId	string	query	Nie

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład update_notification

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.models.update_notification_body import UpdateNotificationBody
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację za pomocą klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    update_notification_body = client.UpdateNotificationBody() # UpdateNotificationBody | 
    user_id = 'user_id_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.update_notification(tenant_id, id, update_notification_body, user_id=user_id)
        print("The response of DefaultApi->update_notification:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->update_notification: %s\n" % e)

add_page

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak

Response

Zwraca: AddPageAPIResponse

Przykład

Przykład add_page

Copy

import client
from client.models.add_page_api_response import AddPageAPIResponse
from client.models.create_api_page_data import CreateAPIPageData
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu,
# który odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    create_api_page_data = client.CreateAPIPageData() # CreateAPIPageData | 
    try:
        api_response = api_instance.add_page(tenant_id, create_api_page_data)
        print("The response of DefaultApi->add_page:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->add_page: %s\n" % e)

delete_page

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: DeletePageAPIResponse

Przykład

Przykład delete_page

Copy

import client
from client.models.delete_page_api_response import DeletePageAPIResponse
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania — użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.delete_page(tenant_id, id)
        print("The response of DefaultApi->delete_page:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_page: %s\n" % e)

get_page_by_urlid

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
urlId	string	query	Tak

Odpowiedź

Zwraca: GetPageByURLIdAPIResponse

Przykład

get_page_by_urlid Przykład

Copy

import client
from client.models.get_page_by_urlid_api_response import GetPageByURLIdAPIResponse
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką zabezpieczeń serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj uwierzytelnianie kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    try:
        api_response = api_instance.get_page_by_urlid(tenant_id, url_id)
        print("The response of DefaultApi->get_page_by_urlid:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_page_by_urlid: %s\n" % e)

get_pages

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak

Odpowiedź

Zwraca: GetPagesAPIResponse

Przykład

Przykład get_pages

Copy

import client
from client.models.get_pages_api_response import GetPagesAPIResponse
from client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://fastcomments.com
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# See configuration.py for a list of all supported configuration parameters.
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
# The client must configure the authentication and authorization parameters
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# in accordance with the API server security policy.
# zgodnie z polityką bezpieczeństwa serwera API.
# Examples for each auth method are provided below, use the example that
# Przykłady dla każdej metody uwierzytelniania znajdują się poniżej, użyj przykładu który
# satisfies your auth use case.
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Configure API key authorization: api_key
# Konfiguracja autoryzacji klucza API: api_key
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, w razie potrzeby
# Enter a context with an instance of the API client
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    try:
        api_response = api_instance.get_pages(tenant_id)
        print("The response of DefaultApi->get_pages:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_pages: %s\n" % e)

patch_page

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: PatchPageAPIResponse

Przykład

Przykład patch_page

Copy

import client
from client.models.patch_page_api_response import PatchPageAPIResponse
from client.models.update_api_page_data import UpdateAPIPageData
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    update_api_page_data = client.UpdateAPIPageData() # UpdateAPIPageData | 
    try:
        api_response = api_instance.patch_page(tenant_id, id, update_api_page_data)
        print("The response of DefaultApi->patch_page:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->patch_page: %s\n" % e)

delete_pending_webhook_event

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Yes
id	string	path	Yes

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład delete_pending_webhook_event

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z zasadami bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj
# tego, który odpowiada Twojemu przypadkowi użycia.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Enter a context with an instance of the API client
with client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.delete_pending_webhook_event(tenant_id, id)
        print("The response of DefaultApi->delete_pending_webhook_event:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_pending_webhook_event: %s\n" % e)

get_pending_webhook_event_count

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
commentId	string	query	Nie
externalId	string	query	Nie
eventType	string	query	Nie
type	string	query	Nie
domain	string	query	Nie
attemptCountGT	number	query	Nie

Odpowiedź

Zwraca: GetPendingWebhookEventCount200Response

Przykład

Przykład get_pending_webhook_event_count

Copy

import client
from client.models.get_pending_webhook_event_count200_response import GetPendingWebhookEventCount200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania; użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelnienia.
# Skonfiguruj autoryzację klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzeba
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str |  (opcjonalne)
    external_id = 'external_id_example' # str |  (opcjonalne)
    event_type = 'event_type_example' # str |  (opcjonalne)
    type = 'type_example' # str |  (opcjonalne)
    domain = 'domain_example' # str |  (opcjonalne)
    attempt_count_gt = 3.4 # float |  (opcjonalne)
    try:
        api_response = api_instance.get_pending_webhook_event_count(tenant_id, comment_id=comment_id, external_id=external_id, event_type=event_type, type=type, domain=domain, attempt_count_gt=attempt_count_gt)
        print("The response of DefaultApi->get_pending_webhook_event_count:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_pending_webhook_event_count: %s\n" % e)

get_pending_webhook_events

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
commentId	string	query	Nie
externalId	string	query	Nie
eventType	string	query	Nie
type	string	query	Nie
domain	string	query	Nie
attemptCountGT	number	query	Nie
skip	number	query	Nie

Odpowiedź

Zwraca: GetPendingWebhookEvents200Response

Przykład

get_pending_webhook_events Przykład

Copy

import client
from client.models.get_pending_webhook_events200_response import GetPendingWebhookEvents200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz plik configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Przykłady dla każdej metody uwierzytelniania znajdują się poniżej — użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Enter a context with an instance of the API client
with client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str |  (optional)
    external_id = 'external_id_example' # str |  (optional)
    event_type = 'event_type_example' # str |  (optional)
    type = 'type_example' # str |  (optional)
    domain = 'domain_example' # str |  (optional)
    attempt_count_gt = 3.4 # float |  (optional)
    skip = 3.4 # float |  (optional)
    try:
        api_response = api_instance.get_pending_webhook_events(tenant_id, comment_id=comment_id, external_id=external_id, event_type=event_type, type=type, domain=domain, attempt_count_gt=attempt_count_gt, skip=skip)
        print("The response of DefaultApi->get_pending_webhook_events:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_pending_webhook_events: %s\n" % e)

create_question_config

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak

Odpowiedź

Zwraca: CreateQuestionConfig200Response

Przykład

Przykład create_question_config

Copy

import client
from client.models.create_question_config200_response import CreateQuestionConfig200Response
from client.models.create_question_config_body import CreateQuestionConfigBody
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania — użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzebne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    create_question_config_body = client.CreateQuestionConfigBody() # CreateQuestionConfigBody | 
    try:
        api_response = api_instance.create_question_config(tenant_id, create_question_config_body)
        print("The response of DefaultApi->create_question_config:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->create_question_config: %s\n" % e)

delete_question_config

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład delete_question_config

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Przykłady dla każdej metody uwierzytelniania znajdują się poniżej, użyj przykładu, który
# odpowiada twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.delete_question_config(tenant_id, id)
        print("The response of DefaultApi->delete_question_config:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_question_config: %s\n" % e)

get_question_config

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: GetQuestionConfig200Response

Przykład

Przykład get_question_config

Copy

import client
from client.models.get_question_config200_response import GetQuestionConfig200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracyjnych.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką zabezpieczeń serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania; użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj uwierzytelnianie za pomocą klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to potrzebne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź do kontekstu z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.get_question_config(tenant_id, id)
        print("The response of DefaultApi->get_question_config:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_question_config: %s\n" % e)

get_question_configs

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
skip	number	query	Nie

Odpowiedź

Zwraca: GetQuestionConfigs200Response

Przykład

Przykład get_question_configs

Copy

import client
from client.models.get_question_configs200_response import GetQuestionConfigs200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz plik configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Przykłady dla każdej metody uwierzytelniania podano poniżej; użyj przykładu, który
# spełnia Twój przypadek użycia uwierzytelniania.
# Konfiguracja autoryzacji kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 3.4 # float |  (opcjonalne)
    try:
        api_response = api_instance.get_question_configs(tenant_id, skip=skip)
        print("The response of DefaultApi->get_question_configs:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_question_configs: %s\n" % e)

update_question_config

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład update_question_config

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.models.update_question_config_body import UpdateQuestionConfigBody
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj
# przykładu, który odpowiada Twojemu przypadkowi użycia.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniższą linię, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    update_question_config_body = client.UpdateQuestionConfigBody() # UpdateQuestionConfigBody | 
    try:
        api_response = api_instance.update_question_config(tenant_id, id, update_question_config_body)
        print("The response of DefaultApi->update_question_config:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->update_question_config: %s\n" % e)

create_question_result

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Yes

Odpowiedź

Zwraca: CreateQuestionResult200Response

Przykład

Przykład create_question_result

Copy

import client
from client.models.create_question_result200_response import CreateQuestionResult200Response
from client.models.create_question_result_body import CreateQuestionResultBody
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Przykłady dla każdej metody autoryzacji są podane poniżej, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzebne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    create_question_result_body = client.CreateQuestionResultBody() # CreateQuestionResultBody | 
    try:
        api_response = api_instance.create_question_result(tenant_id, create_question_result_body)
        print("The response of DefaultApi->create_question_result:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->create_question_result: %s\n" % e)

delete_question_result

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

delete_question_result Przykład

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby poznać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Przykłady dla każdej metody uwierzytelniania są podane poniżej, użyj
# przykładu, który odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli trzeba
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z użyciem instancji klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.delete_question_result(tenant_id, id)
        print("The response of DefaultApi->delete_question_result:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_question_result: %s\n" % e)

get_question_result

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: GetQuestionResult200Response

Przykład

Przykład get_question_result

Copy

import client
from client.models.get_question_result200_response import GetQuestionResult200Response
from client.rest import ApiException
from pprint import pprint
# Ustawienie hosta jest opcjonalne i domyślnie to https://fastcomments.com
# Zobacz configuration.py, aby poznać listę wszystkich wspieranych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Konfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.get_question_result(tenant_id, id)
        print("The response of DefaultApi->get_question_result:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_question_result: %s\n" % e)

get_question_results

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
urlId	string	query	Nie
userId	string	query	Nie
startDate	string	query	Nie
questionId	string	query	Nie
questionIds	string	query	Nie
skip	number	query	Nie

Odpowiedź

Zwraca: GetQuestionResults200Response

Przykład

get_question_results Przykład

Copy

import client
from client.models.get_question_results200_response import GetQuestionResults200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py w celu uzyskania listy wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# spełnia Twoje wymagania dotyczące uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str |  (opcjonalne)
    user_id = 'user_id_example' # str |  (opcjonalne)
    start_date = 'start_date_example' # str |  (opcjonalne)
    question_id = 'question_id_example' # str |  (opcjonalne)
    question_ids = 'question_ids_example' # str |  (opcjonalne)
    skip = 3.4 # float |  (opcjonalne)
    try:
        api_response = api_instance.get_question_results(tenant_id, url_id=url_id, user_id=user_id, start_date=start_date, question_id=question_id, question_ids=question_ids, skip=skip)
        print("The response of DefaultApi->get_question_results:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_question_results: %s\n" % e)

update_question_result

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład update_question_result

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.models.update_question_result_body import UpdateQuestionResultBody
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie używa https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj uwierzytelnianie kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    update_question_result_body = client.UpdateQuestionResultBody() # UpdateQuestionResultBody | 
    try:
        api_response = api_instance.update_question_result(tenant_id, id, update_question_result_body)
        print("The response of DefaultApi->update_question_result:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->update_question_result: %s\n" % e)

aggregate_question_results

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Tak
questionId	string	query	Nie
questionIds	array	query	Nie
urlId	string	query	Nie
timeBucket	string	query	Nie
startDate	string	query	Nie
forceRecalculate	boolean	query	Nie

Odpowiedź

Zwraca: AggregateQuestionResults200Response

Przykład

Przykład aggregate_question_results

Copy

import client
from client.models.aggregate_question_results200_response import AggregateQuestionResults200Response
from client.models.aggregate_time_bucket import AggregateTimeBucket
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby zobaczyć listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    question_id = 'question_id_example' # str |  (opcjonalne)
    question_ids = ['question_ids_example'] # List[str] |  (opcjonalne)
    url_id = 'url_id_example' # str |  (opcjonalne)
    time_bucket = client.AggregateTimeBucket() # AggregateTimeBucket |  (opcjonalne)
    start_date = '2013-10-20T19:20:30+01:00' # datetime |  (opcjonalne)
    force_recalculate = True # bool |  (opcjonalne)
    try:
        api_response = api_instance.aggregate_question_results(tenant_id, question_id=question_id, question_ids=question_ids, url_id=url_id, time_bucket=time_bucket, start_date=start_date, force_recalculate=force_recalculate)
        print("The response of DefaultApi->aggregate_question_results:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->aggregate_question_results: %s\n" % e)

bulk_aggregate_question_results

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
forceRecalculate	boolean	query	Nie

Odpowiedź

Zwraca: BulkAggregateQuestionResults200Response

Przykład

Przykład bulk_aggregate_question_results

Copy

import client
from client.models.bulk_aggregate_question_results200_response import BulkAggregateQuestionResults200Response
from client.models.bulk_aggregate_question_results_request import BulkAggregateQuestionResultsRequest
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdego sposobu uwierzytelniania, użyj tego
# który spełnia Twoje wymagania dotyczące uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzebne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    bulk_aggregate_question_results_request = client.BulkAggregateQuestionResultsRequest() # BulkAggregateQuestionResultsRequest | 
    force_recalculate = True # bool |  (opcjonalne)
    try:
        api_response = api_instance.bulk_aggregate_question_results(tenant_id, bulk_aggregate_question_results_request, force_recalculate=force_recalculate)
        print("The response of DefaultApi->bulk_aggregate_question_results:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->bulk_aggregate_question_results: %s\n" % e)

combine_comments_with_question_results

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Tak
questionId	string	query	Nie
questionIds	array	query	Nie
urlId	string	query	Nie
startDate	string	query	Nie
forceRecalculate	boolean	query	Nie
minValue	number	query	Nie
maxValue	number	query	Nie
limit	number	query	Nie

Odpowiedź

Zwraca: CombineCommentsWithQuestionResults200Response

Przykład

Przykład combine_comments_with_question_results

Copy

import client
from client.models.combine_comments_with_question_results200_response import CombineCommentsWithQuestionResults200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    question_id = 'question_id_example' # str |  (opcjonalne)
    question_ids = ['question_ids_example'] # List[str] |  (opcjonalne)
    url_id = 'url_id_example' # str |  (opcjonalne)
    start_date = '2013-10-20T19:20:30+01:00' # datetime |  (opcjonalne)
    force_recalculate = True # bool |  (opcjonalne)
    min_value = 3.4 # float |  (opcjonalne)
    max_value = 3.4 # float |  (opcjonalne)
    limit = 3.4 # float |  (opcjonalne)
    try:
        api_response = api_instance.combine_comments_with_question_results(tenant_id, question_id=question_id, question_ids=question_ids, url_id=url_id, start_date=start_date, force_recalculate=force_recalculate, min_value=min_value, max_value=max_value, limit=limit)
        print("The response of DefaultApi->combine_comments_with_question_results:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->combine_comments_with_question_results: %s\n" % e)

add_sso_user

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	zapytanie	Tak

Odpowiedź

Zwraca: AddSSOUserAPIResponse

Przykład

Przykład add_sso_user

Copy

import client
from client.models.add_sso_user_api_response import AddSSOUserAPIResponse
from client.models.create_apisso_user_data import CreateAPISSOUserData
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu który
# spełnia Twój przypadek użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzeba
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    create_apisso_user_data = client.CreateAPISSOUserData() # CreateAPISSOUserData | 
    try:
        api_response = api_instance.add_sso_user(tenant_id, create_apisso_user_data)
        print("The response of DefaultApi->add_sso_user:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->add_sso_user: %s\n" % e)

delete_sso_user

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
id	string	path	Tak
deleteComments	boolean	query	Nie
commentDeleteMode	string	query	Nie

Odpowiedź

Zwraca: DeleteSSOUserAPIResponse

Przykład

Przykład delete_sso_user

Copy

import client
from client.models.delete_sso_user_api_response import DeleteSSOUserAPIResponse
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py dla listy wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# spełnia Twoje potrzeby uwierzytelniania.
# Skonfiguruj uwierzytelnianie kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    delete_comments = True # bool |  (opcjonalne)
    comment_delete_mode = 'comment_delete_mode_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.delete_sso_user(tenant_id, id, delete_comments=delete_comments, comment_delete_mode=comment_delete_mode)
        print("The response of DefaultApi->delete_sso_user:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_sso_user: %s\n" % e)

get_sso_user_by_email

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
email	string	path	Tak

Odpowiedź

Zwraca: GetSSOUserByEmailAPIResponse

Przykład

Przykład get_sso_user_by_email

Copy

import client
from client.models.get_sso_user_by_email_api_response import GetSSOUserByEmailAPIResponse
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z zasadami bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu,
# który odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj uwierzytelnianie kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzebne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    email = 'email_example' # str | 
    try:
        api_response = api_instance.get_sso_user_by_email(tenant_id, email)
        print("The response of DefaultApi->get_sso_user_by_email:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_sso_user_by_email: %s\n" % e)

get_sso_user_by_id

Parametry

Name	Type	Location	Required	Description
tenantId	string	zapytanie	Tak
id	string	ścieżka	Tak

Odpowiedź

Zwraca: GetSSOUserByIdAPIResponse

Przykład

Przykład get_sso_user_by_id

Copy

import client
from client.models.get_sso_user_by_id_api_response import GetSSOUserByIdAPIResponse
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z zasadami bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania — użyj
# tego, który odpowiada Twojemu przypadkowi użycia.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.get_sso_user_by_id(tenant_id, id)
        print("The response of DefaultApi->get_sso_user_by_id:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_sso_user_by_id: %s\n" % e)

get_sso_users

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
skip	integer	query	Nie

Odpowiedź

Zwraca: GetSSOUsers200Response

Przykład

Przykład get_sso_users

Copy

import client
from client.models.get_sso_users200_response import GetSSOUsers200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py dla listy wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 56 # int |  (opcjonalne)
    try:
        api_response = api_instance.get_sso_users(tenant_id, skip=skip)
        print("The response of DefaultApi->get_sso_users:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_sso_users: %s\n" % e)

patch_sso_user

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
id	string	path	Tak
updateComments	boolean	query	Nie

Odpowiedź

Zwraca: PatchSSOUserAPIResponse

Przykład

Przykład patch_sso_user

Copy

import client
from client.models.patch_sso_user_api_response import PatchSSOUserAPIResponse
from client.models.update_apisso_user_data import UpdateAPISSOUserData
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu,
# który odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    update_apisso_user_data = client.UpdateAPISSOUserData() # UpdateAPISSOUserData | 
    update_comments = True # bool |  (opcjonalne)
    try:
        api_response = api_instance.patch_sso_user(tenant_id, id, update_apisso_user_data, update_comments=update_comments)
        print("The response of DefaultApi->patch_sso_user:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->patch_sso_user: %s\n" % e)

put_sso_user

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Tak
id	string	path	Tak
updateComments	boolean	query	Nie

Odpowiedź

Zwraca: PutSSOUserAPIResponse

Przykład

put_sso_user Przykład

Copy

import client
from client.models.put_sso_user_api_response import PutSSOUserAPIResponse
from client.models.update_apisso_user_data import UpdateAPISSOUserData
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj tego
# który odpowiada Twojemu przypadkowi użycia.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (e.g. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    update_apisso_user_data = client.UpdateAPISSOUserData() # UpdateAPISSOUserData | 
    update_comments = True # bool |  (opcjonalne)
    try:
        api_response = api_instance.put_sso_user(tenant_id, id, update_apisso_user_data, update_comments=update_comments)
        print("The response of DefaultApi->put_sso_user:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->put_sso_user: %s\n" % e)

create_subscription

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak

Odpowiedź

Zwraca: CreateSubscriptionAPIResponse

Przykład

Przykład create_subscription

Copy

import client
from client.models.create_api_user_subscription_data import CreateAPIUserSubscriptionData
from client.models.create_subscription_api_response import CreateSubscriptionAPIResponse
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby zobaczyć listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania; użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia.
# Skonfiguruj autoryzację klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzeba
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst używając instancji klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    create_api_user_subscription_data = client.CreateAPIUserSubscriptionData() # CreateAPIUserSubscriptionData | 
    try:
        api_response = api_instance.create_subscription(tenant_id, create_api_user_subscription_data)
        print("The response of DefaultApi->create_subscription:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->create_subscription: %s\n" % e)

delete_subscription

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
id	string	path	Tak
userId	string	query	Nie

Odpowiedź

Zwraca: DeleteSubscriptionAPIResponse

Przykład

Przykład delete_subscription

Copy

import client
from client.models.delete_subscription_api_response import DeleteSubscriptionAPIResponse
from client.rest import ApiException
from pprint import pprint
# Definiowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu,
# który odpowiada Twojemu przypadkowi użycia.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    user_id = 'user_id_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.delete_subscription(tenant_id, id, user_id=user_id)
        print("The response of DefaultApi->delete_subscription:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_subscription: %s\n" % e)

get_subscriptions

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
userId	string	query	Nie

Odpowiedź

Zwraca: GetSubscriptionsAPIResponse

Przykład

Przykład get_subscriptions

Copy

import client
from client.models.get_subscriptions_api_response import GetSubscriptionsAPIResponse
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzeba
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.get_subscriptions(tenant_id, user_id=user_id)
        print("The response of DefaultApi->get_subscriptions:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_subscriptions: %s\n" % e)

update_subscription

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Tak
id	string	path	Tak
userId	string	query	Nie

Odpowiedź

Zwraca: UpdateSubscriptionAPIResponse

Przykład

Przykład update_subscription

Copy

import client
from client.models.update_api_user_subscription_data import UpdateAPIUserSubscriptionData
from client.models.update_subscription_api_response import UpdateSubscriptionAPIResponse
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    update_api_user_subscription_data = client.UpdateAPIUserSubscriptionData() # UpdateAPIUserSubscriptionData | 
    user_id = 'user_id_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.update_subscription(tenant_id, id, update_api_user_subscription_data, user_id=user_id)
        print("The response of DefaultApi->update_subscription:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->update_subscription: %s\n" % e)

get_tenant_daily_usages

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
yearNumber	number	query	Nie
monthNumber	number	query	Nie
dayNumber	number	query	Nie
skip	number	query	Nie

Odpowiedź

Zwraca: GetTenantDailyUsages200Response

Przykład

Przykład get_tenant_daily_usages

Copy

import client
from client.models.get_tenant_daily_usages200_response import GetTenantDailyUsages200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie to https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z zasadami bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania,
# użyj przykładu, który odpowiada Twojemu przypadkowi użycia.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzeba
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    year_number = 3.4 # float |  (opcjonalne)
    month_number = 3.4 # float |  (opcjonalne)
    day_number = 3.4 # float |  (opcjonalne)
    skip = 3.4 # float |  (opcjonalne)
    try:
        api_response = api_instance.get_tenant_daily_usages(tenant_id, year_number=year_number, month_number=month_number, day_number=day_number, skip=skip)
        print("The response of DefaultApi->get_tenant_daily_usages:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_tenant_daily_usages: %s\n" % e)

create_tenant_package

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak

Odpowiedź

Zwraca: CreateTenantPackage200Response

Przykład

create_tenant_package Przykład

Copy

import client
from client.models.create_tenant_package200_response import CreateTenantPackage200Response
from client.models.create_tenant_package_body import CreateTenantPackageBody
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj uwierzytelnianie za pomocą klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    create_tenant_package_body = client.CreateTenantPackageBody() # CreateTenantPackageBody | 
    try:
        api_response = api_instance.create_tenant_package(tenant_id, create_tenant_package_body)
        print("The response of DefaultApi->create_tenant_package:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->create_tenant_package: %s\n" % e)

delete_tenant_package

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład delete_tenant_package

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Przykłady dla każdej metody uwierzytelniania znajdują się poniżej, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.delete_tenant_package(tenant_id, id)
        print("The response of DefaultApi->delete_tenant_package:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_tenant_package: %s\n" % e)

get_tenant_package

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: GetTenantPackage200Response

Przykład

get_tenant_package Przykład

Copy

import client
from client.models.get_tenant_package200_response import GetTenantPackage200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania; użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst używając instancji klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.get_tenant_package(tenant_id, id)
        print("The response of DefaultApi->get_tenant_package:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_tenant_package: %s\n" % e)

get_tenant_packages

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Yes
skip	number	query	No

Odpowiedź

Zwraca: GetTenantPackages200Response

Przykład

get_tenant_packages Przykład

Copy

import client
from client.models.get_tenant_packages200_response import GetTenantPackages200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej zamieszczono przykłady dla każdej metody uwierzytelniania, użyj tego,
# który odpowiada Twojemu przypadkowi użycia.
# Konfiguruj uwierzytelnianie kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to potrzebne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 3.4 # float |  (opcjonalne)
    try:
        api_response = api_instance.get_tenant_packages(tenant_id, skip=skip)
        print("The response of DefaultApi->get_tenant_packages:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_tenant_packages: %s\n" % e)

replace_tenant_package

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

replace_tenant_package Przykład

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.models.replace_tenant_package_body import ReplaceTenantPackageBody
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania; użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelnienia.
# Skonfiguruj uwierzytelnianie kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    replace_tenant_package_body = client.ReplaceTenantPackageBody() # ReplaceTenantPackageBody | 
    try:
        api_response = api_instance.replace_tenant_package(tenant_id, id, replace_tenant_package_body)
        print("The response of DefaultApi->replace_tenant_package:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->replace_tenant_package: %s\n" % e)

update_tenant_package

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład update_tenant_package

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.models.update_tenant_package_body import UpdateTenantPackageBody
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z zasadami bezpieczeństwa serwera API.
# Przykłady dla każdej metody uwierzytelniania zostały podane poniżej, użyj przykładu który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Enter a context with an instance of the API client
with client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    update_tenant_package_body = client.UpdateTenantPackageBody() # UpdateTenantPackageBody | 
    try:
        api_response = api_instance.update_tenant_package(tenant_id, id, update_tenant_package_body)
        print("The response of DefaultApi->update_tenant_package:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->update_tenant_package: %s\n" % e)

create_tenant_user

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	zapytanie	Tak

Odpowiedź

Zwraca: CreateTenantUser200Response

Przykład

Przykład create_tenant_user

Copy

import client
from client.models.create_tenant_user200_response import CreateTenantUser200Response
from client.models.create_tenant_user_body import CreateTenantUserBody
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby poznać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania — użyj tego,
# który spełnia Twoje potrzeby uwierzytelniania.
# Konfiguracja uwierzytelniania kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniższą linię, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzeba
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    create_tenant_user_body = client.CreateTenantUserBody() # CreateTenantUserBody | 
    try:
        api_response = api_instance.create_tenant_user(tenant_id, create_tenant_user_body)
        print("The response of DefaultApi->create_tenant_user:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->create_tenant_user: %s\n" % e)

delete_tenant_user

Parametry

Name	Type	Location	Required
tenantId	string	query	Yes
id	string	path	Yes
deleteComments	string	query	No
commentDeleteMode	string	query	No

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład delete_tenant_user

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj tego,
# które odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (e.g. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    delete_comments = 'delete_comments_example' # str |  (opcjonalne)
    comment_delete_mode = 'comment_delete_mode_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.delete_tenant_user(tenant_id, id, delete_comments=delete_comments, comment_delete_mode=comment_delete_mode)
        print("The response of DefaultApi->delete_tenant_user:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_tenant_user: %s\n" % e)

get_tenant_user

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: GetTenantUser200Response

Przykład

Przykład get_tenant_user

Copy

import client
from client.models.get_tenant_user200_response import GetTenantUser200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne, domyślnie ustawione na https://fastcomments.com
# Zobacz plik configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Konfiguracja autoryzacji kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.get_tenant_user(tenant_id, id)
        print("The response of DefaultApi->get_tenant_user:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_tenant_user: %s\n" % e)

get_tenant_users

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
skip	number	query	Nie

Odpowiedź

Zwraca: GetTenantUsers200Response

Przykład

Przykład get_tenant_users

Copy

import client
from client.models.get_tenant_users200_response import GetTenantUsers200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py dla listy wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką zabezpieczeń serwera API.
# Poniżej zamieszczono przykłady dla każdej metody auth, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia auth.
# Skonfiguruj autoryzację za pomocą API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla API key, jeśli potrzeba
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją ApiClient
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 3.4 # float |  (opcjonalne)
    try:
        api_response = api_instance.get_tenant_users(tenant_id, skip=skip)
        print("The response of DefaultApi->get_tenant_users:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_tenant_users: %s\n" % e)

replace_tenant_user

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
id	string	path	Tak
updateComments	string	query	Nie

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

replace_tenant_user Przykład

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.models.replace_tenant_user_body import ReplaceTenantUserBody
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    replace_tenant_user_body = client.ReplaceTenantUserBody() # ReplaceTenantUserBody | 
    update_comments = 'update_comments_example' # str |  (optional)
    try:
        api_response = api_instance.replace_tenant_user(tenant_id, id, replace_tenant_user_body, update_comments=update_comments)
        print("The response of DefaultApi->replace_tenant_user:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->replace_tenant_user: %s\n" % e)

Parametry

Name	Type	Lokalizacja	Wymagane
tenantId	string	query	Tak
id	string	path	Tak
redirectURL	string	query	Nie

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład send_login_link

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    redirect_url = 'redirect_url_example' # str |  (optional)
    try:
        api_response = api_instance.send_login_link(tenant_id, id, redirect_url=redirect_url)
        print("The response of DefaultApi->send_login_link:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->send_login_link: %s\n" % e)

update_tenant_user

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	zapytanie	Tak
id	string	ścieżka	Tak
updateComments	string	zapytanie	Nie

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład update_tenant_user

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.models.update_tenant_user_body import UpdateTenantUserBody
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania; użyj tego,
# który odpowiada Twojemu przypadkowi użycia.
# Skonfiguruj autoryzację klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to potrzebne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    update_tenant_user_body = client.UpdateTenantUserBody() # UpdateTenantUserBody | 
    update_comments = 'update_comments_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.update_tenant_user(tenant_id, id, update_tenant_user_body, update_comments=update_comments)
        print("The response of DefaultApi->update_tenant_user:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->update_tenant_user: %s\n" % e)

create_tenant

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak

Odpowiedź

Zwraca: CreateTenant200Response

Przykład

Przykład create_tenant

Copy

import client
from client.models.create_tenant200_response import CreateTenant200Response
from client.models.create_tenant_body import CreateTenantBody
from client.rest import ApiException
from pprint import pprint
# Ustalenie hosta jest opcjonalne i domyślnie to https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania; użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia.
# Konfiguracja autoryzacji kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    create_tenant_body = client.CreateTenantBody() # CreateTenantBody | 
    try:
        api_response = api_instance.create_tenant(tenant_id, create_tenant_body)
        print("The response of DefaultApi->create_tenant:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->create_tenant: %s\n" % e)

delete_tenant

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
id	string	path	Tak
sure	string	query	Nie

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład delete_tenant

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu który
# spełnia Twoje wymagania uwierzytelniania.
# Skonfiguruj autoryzację klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    sure = 'sure_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.delete_tenant(tenant_id, id, sure=sure)
        print("The response of DefaultApi->delete_tenant:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_tenant: %s\n" % e)

get_tenant

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: GetTenant200Response

Przykład

Przykład get_tenant

Copy

import client
from client.models.get_tenant200_response import GetTenant200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby zobaczyć listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania; użyj tego,
# który odpowiada Twojemu przypadkowi użycia.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.get_tenant(tenant_id, id)
        print("The response of DefaultApi->get_tenant:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_tenant: %s\n" % e)

get_tenants

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
meta	string	query	Nie
skip	number	query	Nie

Odpowiedź

Zwraca: GetTenants200Response

Przykład

Przykład get_tenants

Copy

import client
from client.models.get_tenants200_response import GetTenants200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania; użyj przykładu,
# który odpowiada Twojemu przypadkowi użycia.
# Skonfiguruj autoryzację klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to potrzebne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    meta = 'meta_example' # str |  (opcjonalne)
    skip = 3.4 # float |  (opcjonalne)
    try:
        api_response = api_instance.get_tenants(tenant_id, meta=meta, skip=skip)
        print("The response of DefaultApi->get_tenants:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_tenants: %s\n" % e)

update_tenant

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: FlagCommentPublic200Response

Przykład

Przykład update_tenant

Copy

import client
from client.models.flag_comment_public200_response import FlagCommentPublic200Response
from client.models.update_tenant_body import UpdateTenantBody
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzeba
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    update_tenant_body = client.UpdateTenantBody() # UpdateTenantBody | 
    try:
        api_response = api_instance.update_tenant(tenant_id, id, update_tenant_body)
        print("The response of DefaultApi->update_tenant:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->update_tenant: %s\n" % e)

change_ticket_state

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	zapytanie	Tak
userId	string	zapytanie	Tak
id	string	ścieżka	Tak

Odpowiedź

Zwraca: ChangeTicketState200Response

Przykład

Przykład change_ticket_state

Copy

import client
from client.models.change_ticket_state200_response import ChangeTicketState200Response
from client.models.change_ticket_state_body import ChangeTicketStateBody
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej zamieszczono przykłady dla każdej metody uwierzytelniania; użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Konfiguracja autoryzacji za pomocą klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str | 
    id = 'id_example' # str | 
    change_ticket_state_body = client.ChangeTicketStateBody() # ChangeTicketStateBody | 
    try:
        api_response = api_instance.change_ticket_state(tenant_id, user_id, id, change_ticket_state_body)
        print("The response of DefaultApi->change_ticket_state:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->change_ticket_state: %s\n" % e)

create_ticket

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
userId	string	query	Tak

Odpowiedź

Zwraca: CreateTicket200Response

Przykład

Przykład create_ticket

Copy

import client
from client.models.create_ticket200_response import CreateTicket200Response
from client.models.create_ticket_body import CreateTicketBody
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej zamieszczono przykłady dla każdej metody uwierzytelniania — użyj tego,
# który odpowiada Twojemu przypadkowi użycia.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str | 
    create_ticket_body = client.CreateTicketBody() # CreateTicketBody | 
    try:
        api_response = api_instance.create_ticket(tenant_id, user_id, create_ticket_body)
        print("The response of DefaultApi->create_ticket:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->create_ticket: %s\n" % e)

get_ticket

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
id	string	path	Tak
userId	string	query	Nie

Odpowiedź

Zwraca: GetTicket200Response

Przykład

Przykład get_ticket

Copy

import client
from client.models.get_ticket200_response import GetTicket200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py dla listy wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania; użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    user_id = 'user_id_example' # str |  (opcjonalnie)
    try:
        api_response = api_instance.get_ticket(tenant_id, id, user_id=user_id)
        print("The response of DefaultApi->get_ticket:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_ticket: %s\n" % e)

get_tickets

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Tak
userId	string	query	Nie
state	number	query	Nie
skip	number	query	Nie
limit	number	query	Nie

Odpowiedź

Zwraca: GetTickets200Response

Przykład

get_tickets Przykład

Copy

import client
from client.models.get_tickets200_response import GetTickets200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj uwierzytelnianie kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst używając instancji klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (opcjonalne)
    state = 3.4 # float |  (opcjonalne)
    skip = 3.4 # float |  (opcjonalne)
    limit = 3.4 # float |  (opcjonalne)
    try:
        api_response = api_instance.get_tickets(tenant_id, user_id=user_id, state=state, skip=skip, limit=limit)
        print("The response of DefaultApi->get_tickets:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_tickets: %s\n" % e)

upload_image

Prześlij i zmień rozmiar obrazu

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	path	Tak
sizePreset	string	query	Nie	Predefiniowany rozmiar: "Default" (1000x1000px) lub "CrossPlatform" (tworzy rozmiary dla popularnych urządzeń)
urlId	string	query	Nie	Id strony, z której odbywa się przesyłanie, do konfiguracji

Odpowiedź

Zwraca: UploadImageResponse

Przykład

Przykład upload_image

Copy

import client
from client.models.size_preset import SizePreset
from client.models.upload_image_response import UploadImageResponse
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Wejdź do kontekstu z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    file = None # bytearray | 
    size_preset = client.SizePreset() # SizePreset | Predefiniowany rozmiar: \"Default\" (1000x1000px) lub \"CrossPlatform\" (tworzy rozmiary dla popularnych urządzeń) (opcjonalne)
    url_id = 'url_id_example' # str | Id strony, z której odbywa się przesyłanie, do konfiguracji (opcjonalne)
    try:
        api_response = api_instance.upload_image(tenant_id, file, size_preset=size_preset, url_id=url_id)
        print("The response of PublicApi->upload_image:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->upload_image: %s\n" % e)

get_user_badge_progress_by_id

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: GetUserBadgeProgressById200Response

Przykład

Przykład get_user_badge_progress_by_id

Copy

import client
from client.models.get_user_badge_progress_by_id200_response import GetUserBadgeProgressById200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby zobaczyć listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzebne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.get_user_badge_progress_by_id(tenant_id, id)
        print("The response of DefaultApi->get_user_badge_progress_by_id:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_user_badge_progress_by_id: %s\n" % e)

get_user_badge_progress_by_user_id

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
userId	string	path	Tak

Odpowiedź

Zwraca: GetUserBadgeProgressById200Response

Przykład

Przykład get_user_badge_progress_by_user_id

Copy

import client
from client.models.get_user_badge_progress_by_id200_response import GetUserBadgeProgressById200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej zamieszczono przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str | 
    try:
        api_response = api_instance.get_user_badge_progress_by_user_id(tenant_id, user_id)
        print("The response of DefaultApi->get_user_badge_progress_by_user_id:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_user_badge_progress_by_user_id: %s\n" % e)

get_user_badge_progress_list

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
userId	string	query	Nie
limit	number	query	Nie
skip	number	query	Nie

Odpowiedź

Zwraca: GetUserBadgeProgressList200Response

Przykład

Przykład użycia get_user_badge_progress_list

Copy

import client
from client.models.get_user_badge_progress_list200_response import GetUserBadgeProgressList200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracyjnych.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia.
# Konfiguracja autoryzacji kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić przedrostek (np. Bearer) dla klucza API, jeśli to potrzebne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (opcjonalne)
    limit = 3.4 # float |  (opcjonalne)
    skip = 3.4 # float |  (opcjonalne)
    try:
        api_response = api_instance.get_user_badge_progress_list(tenant_id, user_id=user_id, limit=limit, skip=skip)
        print("The response of DefaultApi->get_user_badge_progress_list:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_user_badge_progress_list: %s\n" % e)

create_user_badge

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak

Odpowiedź

Zwraca: CreateUserBadge200Response

Przykład

Przykład create_user_badge

Copy

import client
from client.models.create_user_badge200_response import CreateUserBadge200Response
from client.models.create_user_badge_params import CreateUserBadgeParams
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania — użyj tego,
# który odpowiada Twojemu przypadkowi użycia.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź do kontekstu z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    create_user_badge_params = client.CreateUserBadgeParams() # CreateUserBadgeParams | 
    try:
        api_response = api_instance.create_user_badge(tenant_id, create_user_badge_params)
        print("The response of DefaultApi->create_user_badge:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->create_user_badge: %s\n" % e)

delete_user_badge

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: UpdateUserBadge200Response

Przykład

Przykład delete_user_badge

Copy

import client
from client.models.update_user_badge200_response import UpdateUserBadge200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką zabezpieczeń serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania — użyj
# przykładu, który odpowiada Twojemu przypadkowi użycia.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.delete_user_badge(tenant_id, id)
        print("The response of DefaultApi->delete_user_badge:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_user_badge: %s\n" % e)

get_user_badge

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: GetUserBadge200Response

Przykład

Przykład get_user_badge

Copy

import client
from client.models.get_user_badge200_response import GetUserBadge200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania; użyj przykładu, który
# spełnia Twoje wymagania uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.get_user_badge(tenant_id, id)
        print("The response of DefaultApi->get_user_badge:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_user_badge: %s\n" % e)

get_user_badges

Parametry

Name	Type	Location	Wymagane
tenantId	string	query	Tak
userId	string	query	Nie
badgeId	string	query	Nie
type	number	query	Nie
displayedOnComments	boolean	query	Nie
limit	number	query	Nie
skip	number	query	Nie

Odpowiedź

Zwraca: GetUserBadges200Response

Przykład

get_user_badges Przykład

Copy

import client
from client.models.get_user_badges200_response import GetUserBadges200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania — użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia.
# Konfiguracja autoryzacji kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (opcjonalne)
    badge_id = 'badge_id_example' # str |  (opcjonalne)
    type = 3.4 # float |  (opcjonalne)
    displayed_on_comments = True # bool |  (opcjonalne)
    limit = 3.4 # float |  (opcjonalne)
    skip = 3.4 # float |  (opcjonalne)
    try:
        api_response = api_instance.get_user_badges(tenant_id, user_id=user_id, badge_id=badge_id, type=type, displayed_on_comments=displayed_on_comments, limit=limit, skip=skip)
        print("The response of DefaultApi->get_user_badges:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_user_badges: %s\n" % e)

update_user_badge

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: UpdateUserBadge200Response

Przykład

update_user_badge Przykład

Copy

import client
from client.models.update_user_badge200_response import UpdateUserBadge200Response
from client.models.update_user_badge_params import UpdateUserBadgeParams
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Użyj kontekstu z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    update_user_badge_params = client.UpdateUserBadgeParams() # UpdateUserBadgeParams | 
    try:
        api_response = api_instance.update_user_badge(tenant_id, id, update_user_badge_params)
        print("The response of DefaultApi->update_user_badge:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->update_user_badge: %s\n" % e)

get_user_notification_count

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	zapytanie	Tak
sso	string	zapytanie	Nie

Odpowiedź

Zwraca: GetUserNotificationCount200Response

Przykład

Przykład get_user_notification_count

Copy

import client
from client.models.get_user_notification_count200_response import GetUserNotificationCount200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.get_user_notification_count(tenant_id, sso=sso)
        print("The response of PublicApi->get_user_notification_count:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_user_notification_count: %s\n" % e)

get_user_notifications

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
pageSize	integer	query	Nie
afterId	string	query	Nie
includeContext	boolean	query	Nie
afterCreatedAt	integer	query	Nie
unreadOnly	boolean	query	Nie
dmOnly	boolean	query	Nie
noDm	boolean	query	Nie
includeTranslations	boolean	query	Nie
sso	string	query	Nie

Response

Zwraca: GetUserNotifications200Response

Przykład

Przykład get_user_notifications

Copy

import client
from client.models.get_user_notifications200_response import GetUserNotifications200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    page_size = 56 # int |  (opcjonalne)
    after_id = 'after_id_example' # str |  (opcjonalne)
    include_context = True # bool |  (opcjonalne)
    after_created_at = 56 # int |  (opcjonalne)
    unread_only = True # bool |  (opcjonalne)
    dm_only = True # bool |  (opcjonalne)
    no_dm = True # bool |  (opcjonalne)
    include_translations = True # bool |  (opcjonalne)
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.get_user_notifications(tenant_id, page_size=page_size, after_id=after_id, include_context=include_context, after_created_at=after_created_at, unread_only=unread_only, dm_only=dm_only, no_dm=no_dm, include_translations=include_translations, sso=sso)
        print("The response of PublicApi->get_user_notifications:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_user_notifications: %s\n" % e)

reset_user_notification_count

Parametry

Name	Type	Location	Required	Description
tenantId	string	query	Yes
sso	string	query	No

Odpowiedź

Zwraca: ResetUserNotifications200Response

Przykład

Przykład reset_user_notification_count

Copy

import client
from client.models.reset_user_notifications200_response import ResetUserNotifications200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie to https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.reset_user_notification_count(tenant_id, sso=sso)
        print("The response of PublicApi->reset_user_notification_count:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->reset_user_notification_count: %s\n" % e)

reset_user_notifications

Parametry

Nazwa	Type	Location	Wymagane
tenantId	string	query	Tak
afterId	string	query	Nie
afterCreatedAt	integer	query	Nie
unreadOnly	boolean	query	Nie
dmOnly	boolean	query	Nie
noDm	boolean	query	Nie
sso	string	query	Nie

Odpowiedź

Zwraca: ResetUserNotifications200Response

Przykład

Przykład reset_user_notifications

Copy

import client
from client.models.reset_user_notifications200_response import ResetUserNotifications200Response
from client.rest import ApiException
from pprint import pprint
# Ustalenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py dla listy wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    after_id = 'after_id_example' # str |  (opcjonalne)
    after_created_at = 56 # int |  (opcjonalne)
    unread_only = True # bool |  (opcjonalne)
    dm_only = True # bool |  (opcjonalne)
    no_dm = True # bool |  (opcjonalne)
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.reset_user_notifications(tenant_id, after_id=after_id, after_created_at=after_created_at, unread_only=unread_only, dm_only=dm_only, no_dm=no_dm, sso=sso)
        print("The response of PublicApi->reset_user_notifications:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->reset_user_notifications: %s\n" % e)

update_user_notification_comment_subscription_status

Włącz lub wyłącz powiadomienia dla konkretnego komentarza.

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Yes
notificationId	string	path	Yes
optedInOrOut	string	path	Yes
commentId	string	query	Yes
sso	string	query	No

Odpowiedź

Zwraca: UpdateUserNotificationStatus200Response

Przykład

Przykład update_user_notification_comment_subscription_status

Copy

import client
from client.models.update_user_notification_status200_response import UpdateUserNotificationStatus200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    notification_id = 'notification_id_example' # str | 
    opted_in_or_out = 'opted_in_or_out_example' # str | 
    comment_id = 'comment_id_example' # str | 
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.update_user_notification_comment_subscription_status(tenant_id, notification_id, opted_in_or_out, comment_id, sso=sso)
        print("The response of PublicApi->update_user_notification_comment_subscription_status:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->update_user_notification_comment_subscription_status: %s\n" % e)

update_user_notification_page_subscription_status

Włącz lub wyłącz powiadomienia dla strony. Gdy użytkownicy subskrybują stronę, tworzone są powiadomienia dla nowych komentarzy głównych, a także

Parametry

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

Odpowiedź

Zwraca: UpdateUserNotificationStatus200Response

Przykład

update_user_notification_page_subscription_status Przykład

Copy

import client
from client.models.update_user_notification_status200_response import UpdateUserNotificationStatus200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne; domyślnie używane jest https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    url = 'url_example' # str | 
    page_title = 'page_title_example' # str | 
    subscribed_or_unsubscribed = 'subscribed_or_unsubscribed_example' # str | 
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.update_user_notification_page_subscription_status(tenant_id, url_id, url, page_title, subscribed_or_unsubscribed, sso=sso)
        print("The response of PublicApi->update_user_notification_page_subscription_status:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->update_user_notification_page_subscription_status: %s\n" % e)

update_user_notification_status

Parametry

Nazwa	Typ	Location	Wymagane
tenantId	string	query	Tak
notificationId	string	path	Tak
newStatus	string	path	Tak
sso	string	query	Nie

Odpowiedź

Zwraca: UpdateUserNotificationStatus200Response

Przykład

Przykład update_user_notification_status

Copy

import client
from client.models.update_user_notification_status200_response import UpdateUserNotificationStatus200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    notification_id = 'notification_id_example' # str | 
    new_status = 'new_status_example' # str | 
    sso = 'sso_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.update_user_notification_status(tenant_id, notification_id, new_status, sso=sso)
        print("The response of PublicApi->update_user_notification_status:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->update_user_notification_status: %s\n" % e)

get_user_presence_statuses

Parametry

Name	Type	Location	Required
tenantId	string	query	Yes
urlIdWS	string	query	Yes
userIds	string	query	Yes

Odpowiedź

Zwraca: GetUserPresenceStatuses200Response

Przykład

Przykład get_user_presence_statuses

Copy

import client
from client.models.get_user_presence_statuses200_response import GetUserPresenceStatuses200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id_ws = 'url_id_ws_example' # str | 
    user_ids = 'user_ids_example' # str | 
    try:
        api_response = api_instance.get_user_presence_statuses(tenant_id, url_id_ws, user_ids)
        print("The response of PublicApi->get_user_presence_statuses:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_user_presence_statuses: %s\n" % e)

search_users

Parametry

Name	Type	Location	Required
tenantId	string	path	Tak
urlId	string	query	Tak
usernameStartsWith	string	query	Nie
mentionGroupIds	array	query	Nie
sso	string	query	Nie
searchSection	string	query	Nie

Odpowiedź

Zwraca: SearchUsers200Response

Przykład

Przykład search_users

Copy

import client
from client.models.search_users200_response import SearchUsers200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Otwórz kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    username_starts_with = 'username_starts_with_example' # str |  (opcjonalne)
    mention_group_ids = ['mention_group_ids_example'] # List[str] |  (opcjonalne)
    sso = 'sso_example' # str |  (opcjonalne)
    search_section = 'search_section_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.search_users(tenant_id, url_id, username_starts_with=username_starts_with, mention_group_ids=mention_group_ids, sso=sso, search_section=search_section)
        print("The response of PublicApi->search_users:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->search_users: %s\n" % e)

get_user

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
id	string	path	Tak

Odpowiedź

Zwraca: GetUser200Response

Przykład

Przykład get_user

Copy

import client
from client.models.get_user200_response import GetUser200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody uwierzytelniania, użyj przykładu który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Konfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli potrzeba
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.get_user(tenant_id, id)
        print("The response of DefaultApi->get_user:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_user: %s\n" % e)

create_vote

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
commentId	string	query	Tak
direction	string	query	Tak
userId	string	query	Nie
anonUserId	string	query	Nie

Odpowiedź

Zwraca: VoteComment200Response

Przykład

Przykład create_vote

Copy

import client
from client.models.vote_comment200_response import VoteComment200Response
from client.rest import ApiException
from pprint import pprint
# Zdefiniowanie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py dla listy wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Przykłady dla każdej metody uwierzytelniania są podane poniżej, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Enter a context with an instance of the API client
with client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    direction = 'direction_example' # str | 
    user_id = 'user_id_example' # str |  (opcjonalne)
    anon_user_id = 'anon_user_id_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.create_vote(tenant_id, comment_id, direction, user_id=user_id, anon_user_id=anon_user_id)
        print("The response of DefaultApi->create_vote:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->create_vote: %s\n" % e)

delete_vote

Parametry

Nazwa	Typ	Lokalizacja	Wymagane
tenantId	string	query	Tak
id	string	path	Tak
editKey	string	query	Nie

Odpowiedź

Zwraca: DeleteCommentVote200Response

Przykład

Przykład delete_vote

Copy

import client
from client.models.delete_comment_vote200_response import DeleteCommentVote200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia uwierzytelniania.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli jest potrzebny
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    edit_key = 'edit_key_example' # str |  (optional)
    try:
        api_response = api_instance.delete_vote(tenant_id, id, edit_key=edit_key)
        print("The response of DefaultApi->delete_vote:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_vote: %s\n" % e)

get_votes

Parametry

Nazwa	Typ	Lokalizacja	Wymagane	Opis
tenantId	string	query	Tak
urlId	string	query	Tak

Odpowiedź

Zwraca: GetVotes200Response

Przykład

Przykład get_votes

Copy

import client
from client.models.get_votes200_response import GetVotes200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie to https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej podano przykłady dla każdej metody uwierzytelniania, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia.
# Skonfiguruj autoryzację kluczem API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    try:
        api_response = api_instance.get_votes(tenant_id, url_id)
        print("The response of DefaultApi->get_votes:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_votes: %s\n" % e)

get_votes_for_user

Parametry

Name	Type	Location	Required
tenantId	string	query	Tak
urlId	string	query	Tak
userId	string	query	Nie
anonUserId	string	query	Nie

Odpowiedź

Zwraca: GetVotesForUser200Response

Przykład

Przykład get_votes_for_user

Copy

import client
from client.models.get_votes_for_user200_response import GetVotesForUser200Response
from client.rest import ApiException
from pprint import pprint
# Określenie hosta jest opcjonalne i domyślnie ustawione na https://fastcomments.com
# Zobacz configuration.py, aby uzyskać listę wszystkich obsługiwanych parametrów konfiguracji.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Klient musi skonfigurować parametry uwierzytelniania i autoryzacji
# zgodnie z polityką bezpieczeństwa serwera API.
# Poniżej znajdują się przykłady dla każdej metody autoryzacji, użyj przykładu, który
# odpowiada Twojemu przypadkowi użycia.
# Skonfiguruj autoryzację za pomocą klucza API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Odkomentuj poniżej, aby ustawić prefiks (np. Bearer) dla klucza API, jeśli to konieczne
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Wejdź w kontekst z instancją klienta API
with client.ApiClient(configuration) as api_client:
    # Utwórz instancję klasy API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    user_id = 'user_id_example' # str |  (opcjonalne)
    anon_user_id = 'anon_user_id_example' # str |  (opcjonalne)
    try:
        api_response = api_instance.get_votes_for_user(tenant_id, url_id, user_id=user_id, anon_user_id=anon_user_id)
        print("The response of DefaultApi->get_votes_for_user:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_votes_for_user: %s\n" % e)

Potrzebujesz pomocy?

Jeśli napotkasz jakiekolwiek problemy lub masz pytania dotyczące SDK Pythona, prosimy:

Contributing

Wkład jest mile widziany! Proszę odwiedzić repozytorium GitHub w celu zapoznania się z wytycznymi dotyczącymi kontrybucji.

Język 🇵🇱 Polski

Pierwsze kroki

Dokumentacja

Agregacja

Logi audytu

Blokowanie z komentarza

Sprawdzanie zablokowanych komentarzy

Komentarze

Konfiguracje domen

Szablony e-mail

Dziennik zdarzeń

Wpisy w kanale

Zgłaszanie komentarza

Hashtagi

Moderatorzy

Liczba powiadomień

Powiadomienia

Strony

Oczekujące zdarzenia webhook

Konfiguracje pytań

Wyniki pytań

Agregacja wyników pytań

Użytkownicy SSO

Subskrypcje

Dzienne użycie najemcy

Pakiety najemcy

Użytkownicy najemcy

Najemcy

Zgłoszenia

Prześlij obraz

Postęp odznak użytkownika

Odznaki użytkownika

Powiadomienia użytkownika

Status obecności użytkownika

Wyszukiwanie użytkowników

Użytkownicy

Głosy

FastComments Python SDK

Repozytorium

Instalacja

PyPI

Library Contents

Publiczne vs zabezpieczone API

Szybki start

Korzystanie z uwierzytelnionych API (DefaultApi)

Korzystanie z publicznych API (PublicApi)

Korzystanie z SSO (Single Sign-On)

Częste problemy

Notatki

Identyfikatory Broadcast

Wymagania

aggregate

Parametry

Odpowiedź

Przykład

get_audit_logs

Parametry

Odpowiedź

Przykład

block_from_comment_public

Parametry

Odpowiedź

Przykład

un_block_comment_public

Parametry

Odpowiedź

Przykład

checked_comments_for_blocked

Parametry

Response

Przykład

block_user_from_comment

Parametry

Odpowiedź

Przykład

create_comment_public

Parametry

Odpowiedź

Przykład

delete_comment