SDK Python FastComments

Questo è l'SDK Python ufficiale per FastComments.

SDK Python ufficiale per l'API di FastComments

Repository

Agenti di codifica IA

Fornisci al tuo agente di codifica il contesto FastComments di cui ha bisogno - widget, configurazione, Secure SSO, la REST API e gli SDK:

npx skills add fastcomments/skills

Funziona con Claude Code, Codex, Cursor, Copilot, Gemini e tutti gli altri agenti supportati dal skills CLI.

Installazione

Installa da GitHub

Installa direttamente da un tag di rilascio (consigliato, completamente riproducibile):

pip install git+https://github.com/fastcomments/fastcomments-python.git@v3.1.0

Fissa il tag anziché un branch così le build sono deterministiche. La stessa forma funziona in requirements.txt:

fastcomments @ git+https://github.com/fastcomments/fastcomments-python.git@v3.1.0

Ogni GitHub Release con tag ha anche una wheel compilata allegata se preferisci installare direttamente un artefatto binario.

Contenuto della Libreria

Questa libreria contiene due moduli: il client API generato e la libreria core Python che contiene utility scritte a mano per facilitare l'uso dell'API, incluso il supporto SSO.

API Pubbliche vs Sicure

Per il client API, ci sono tre classi, DefaultApi, PublicApi e ModerationApi. DefaultApi contiene metodi che richiedono la tua chiave API, e PublicApi contiene metodi che possono essere chiamati direttamente da un browser/dispositivo mobile/etc senza autenticazione. ModerationApi fornisce una suite estesa di API di moderazione in tempo reale e veloci. Ogni metodo ModerationApi accetta un parametro sso e può autenticarsi tramite SSO o un cookie di sessione FastComments.com.

Avvio rapido

Using Authenticated APIs (DefaultApi)

Important: You must set your API key on the Configuration before making authenticated requests. If you don't, requests will fail with a 401 error.

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

# Crea e configura il client API
config = Configuration()
config.host = "https://fastcomments.com"

# OBBLIGATORIO: Imposta la tua chiave API (ottienila dalla dashboard di FastComments)
config.api_key = {"api_key": "YOUR_API_KEY_HERE"}

# Crea l'istanza API con il client configurato
api_client = ApiClient(configuration=config)
api = DefaultApi(api_client)

# Ora puoi effettuare chiamate API autenticate
try:
    # Esempio: Aggiungi un utente SSO
    user_data = CreateAPISSOUserData(
        id="user-123",
        email="user@example.com",
        display_name="John Doe"
    )

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

except Exception as e:
    print(f"Error: {e}")
    # Errori comuni:
    - 401: API key is missing or invalid
    - 400: Request validation failed

Using Public APIs (PublicApi)

Gli endpoint pubblici non richiedono autenticazione:

from client import ApiClient, Configuration, PublicApi

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

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

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

Using the Moderation Dashboard (ModerationApi)

The ModerationApi powers the moderator dashboard. Methods are called on behalf of a moderator by passing an sso token:

from client import ApiClient, Configuration, ModerationApi
from client.api.moderation_api import GetCountOptions

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

api_client = ApiClient(configuration=config)
moderation_api = ModerationApi(api_client)

try:
    # Conta i commenti in attesa di moderazione
    response = moderation_api.get_count(GetCountOptions(sso="SSO_TOKEN"))
    print(response)
except Exception as e:
    print(f"Error: {e}")

Using SSO (Single Sign-On)

The SDK includes utilities for generating secure SSO tokens:

from sso import FastCommentsSSO, SecureSSOUserData

# Crea i dati utente (id, email e username sono obbligatori)
user_data = SecureSSOUserData(
    id="user-123",
    email="user@example.com",
    username="johndoe",
    avatar="https://example.com/avatar.jpg"
)

# Firmalo con il tuo segreto API (HMAC-SHA256)
sso = FastCommentsSSO.new_secure("YOUR_API_SECRET", user_data)

# Genera il token SSO da passare al widget o a una chiamata API
sso_token = sso.create_token()

# Usa questo token nel tuo frontend o passalo alle chiamate API
print(f"SSO Token: {sso_token}")

Per SSO semplice (meno sicuro, per test):

from sso import FastCommentsSSO, SimpleSSOUserData

user_data = SimpleSSOUserData(
    username="johndoe",
    email="user@example.com"
)

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

Live Subscriptions (PubSub)

The pubsub module lets you subscribe to real-time comment events (new comments, votes, edits, notifications, etc.) over a WebSocket, mirroring the FastComments Java SDK's LiveEventSubscriber. It requires the pubsub extra, which adds a WebSocket client on top of the generated API client:

pip install "fastcomments[pubsub] @ git+https://github.com/fastcomments/fastcomments-python.git@v3.1.0"

from pubsub import LiveEventSubscriber

subscriber = LiveEventSubscriber()

def handle_live_event(event):
    print(f"Live event: {event.type}")
    if event.comment:
        print(f"  comment: {event.comment.comment}")

result = subscriber.subscribe_to_changes(
    tenant_id_ws="YOUR_TENANT_ID",
    url_id="page-url-id",
    url_id_ws="page-url-id",
    user_id_ws="a-unique-presence-id",  # ad es. un UUID per questa sessione
    handle_live_event=handle_live_event,
    on_connection_status_change=lambda connected, last_event_time: print(
        f"connected={connected}"
    ),
    region=None,  # impostalo a "eu" per la regione EU
)

# ... più tardi, quando non vuoi più aggiornamenti:
result.close()

The subscriber runs the connection on a background daemon thread, transparently reconnects with jitter, and fetches any events missed while disconnected from the event-log endpoint on reconnect. Pass an optional can_see_comments callback (List[str] -> Dict[str, str], returning the ids the user may NOT see) to filter out events for comments the user is not allowed to view. Set disable_live_commenting=True to make subscribe_to_changes a no-op that returns None.

Common Issues

401 "missing-api-key" error: Assicurati di impostare config.api_key = {"api_key": "YOUR_KEY"} prima di creare l'istanza DefaultApi.
Wrong API class: Usa DefaultApi per richieste autenticate lato server, PublicApi per richieste lato client/pubbliche, e ModerationApi per richieste della dashboard dei moderatori.
Import errors: Assicurati di importare dal modulo corretto:
- Client API: from client import ...
- Utility SSO: from sso import ...
- Sottoscrizioni live: from pubsub import ... (richiede l'extra pubsub)

Note

ID di Broadcast

Vedrai che devi passare un broadcast_id in alcune chiamate API. Quando ricevi eventi, otterrai indietro questo ID, così saprai di ignorare l'evento se intendi applicare i cambiamenti in modo ottimistico sul client (cosa che probabilmente vorrai fare, poiché offre la migliore esperienza). Passa un UUID qui. L'ID dovrebbe essere sufficientemente unico da non ripetersi due volte in una sessione del browser.

Requisiti

Python >= 3.8

L'installazione di base è pure-stdlib e fornisce le utility SSO. Il client API generato (DefaultApi/PublicApi/ModerationApi) richiede l'extra client, che include urllib3 >= 1.25.3, python-dateutil >= 2.8.2, pydantic >= 2.0.0 e typing-extensions >= 4.0.0:

pip install "fastcomments[client] @ git+https://github.com/fastcomments/fastcomments-python.git@v3.1.0"

aggregare

Aggrega i documenti raggruppandoli (se groupBy è fornito) e applicando più operazioni.
Sono supportate diverse operazioni (ad es. sum, countDistinct, avg, ecc.).

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
parentTenantId	string	query	No
includeStats	boolean	query	No

Response

Returns: AggregateResponse

Example

Esempio di aggregazione

Copy

import client
from client.api.default_api import AggregateOptions
from client.models.aggregate_response import AggregateResponse
from client.models.aggregation_request import AggregationRequest
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite chiave API: api_key
# Decommenta qui sotto per impostare il prefisso (ad es. Bearer) per la chiave API, se necessario
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'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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, AggregateOptions(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)

ottieni_log_audit

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
limit	number	query	No
skip	number	query	No
order	string	query	No
after	number	query	No
before	number	query	No

Risposta

Restituisce: GetAuditLogsResponse

Esempio

Esempio get_audit_logs

Copy

import client
from client.api.default_api import GetAuditLogsOptions
from client.models.get_audit_logs_response import GetAuditLogsResponse
from client.models.sortdir import SORTDIR
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    limit = 3.4 # float |  (optional)
    skip = 3.4 # float |  (optional)
    order = client.SORTDIR() # SORTDIR |  (optional)
    after = 3.4 # float |  (optional)
    before = 3.4 # float |  (optional)
    try:
        api_response = api_instance.get_audit_logs(tenant_id, GetAuditLogsOptions(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)

logout_pubblico

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di logout_public

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Consulta configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    try:
        api_response = api_instance.logout_public()
        print("The response of PublicApi->logout_public:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->logout_public: %s\n" % e)

blocca_da_commento_pubblico

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
commentId	string	path	Sì
sso	string	query	No

Risposta

Restituisce: BlockSuccess

Esempio

Esempio di block_from_comment_public

Copy

import client
from client.models.block_success import BlockSuccess
from client.models.public_block_from_comment_params import PublicBlockFromCommentParams
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è facoltativa e di default è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (opzionale)
    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)

sblocca_commento_pubblico

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
commentId	string	path	Sì
sso	string	query	No

Risposta

Restituisce: UnblockSuccess

Esempio

Esempio di un_block_comment_public

Copy

import client
from client.models.public_block_from_comment_params import PublicBlockFromCommentParams
from client.models.unblock_success import UnblockSuccess
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Consulta configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (opzionale)
    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)

commenti_controllati_per_bloccati

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì
commentIds	string	query	Sì	Una lista separata da virgole di id dei commenti.
sso	string	query	No

Risposta

Restituisce: CheckBlockedCommentsResponse

Esempio

Esempio di checked_comments_for_blocked

Copy

import client
from client.models.check_blocked_comments_response import CheckBlockedCommentsResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_ids = 'comment_ids_example' # str | Una lista separata da virgole di id dei commenti.
    sso = 'sso_example' # str |  (opzionale)
    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)

blocca_utente_da_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
id	string	path	Yes
userId	string	query	No
anonUserId	string	query	No

Risposta

Restituisce: BlockSuccess

Esempio

Esempio block_user_from_comment

Copy

import client
from client.api.default_api import BlockUserFromCommentOptions
from client.models.block_from_comment_params import BlockFromCommentParams
from client.models.block_success import BlockSuccess
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Vengono forniti esempi per ciascun metodo di auth, usare l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configurare l'autorizzazione tramite chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommentare qui sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    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, BlockUserFromCommentOptions(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)

crea_commento_pubblico

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Sì
urlId	string	query	Sì
broadcastId	string	query	Sì
sessionId	string	query	No
sso	string	query	No

Risposta

Restituisce: SaveCommentsResponseWithPresence

Esempio

Esempio create_comment_public

Copy

import client
from client.api.public_api import CreateCommentPublicOptions
from client.models.comment_data import CommentData
from client.models.save_comments_response_with_presence import SaveCommentsResponseWithPresence
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Inserire un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe 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 |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.create_comment_public(tenant_id, url_id, broadcast_id, comment_data, CreateCommentPublicOptions(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)

elimina_commento

Parameters

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
id	string	path	Sì
contextUserId	string	query	No
isLive	boolean	query	No

Response

Restituisce: DeleteCommentResult

Example

Esempio delete_comment

Copy

import client
from client.api.default_api import DeleteCommentOptions
from client.models.delete_comment_result import DeleteCommentResult
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per l'elenco di tutti i parametri di configurazione supportati.
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, utilizzare l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione della chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (optional)
    is_live = True # bool |  (optional)
    try:
        api_response = api_instance.delete_comment(tenant_id, id, DeleteCommentOptions(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)

elimina_commento_pubblico

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Sì
commentId	string	path	Sì
broadcastId	string	query	Sì
editKey	string	query	No
sso	string	query	No

Risposta

Returns: PublicAPIDeleteCommentResponse

Esempio

delete_comment_public Esempio

Copy

import client
from client.api.public_api import DeleteCommentPublicOptions
from client.models.public_api_delete_comment_response import PublicAPIDeleteCommentResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe 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 |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.delete_comment_public(tenant_id, comment_id, broadcast_id, DeleteCommentPublicOptions(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)

elimina_voto_commento

Parameters

Name	Type	Location	Required
tenantId	string	path	Sì
commentId	string	path	Sì
voteId	string	path	Sì
urlId	string	query	Sì
broadcastId	string	query	Sì
editKey	string	query	No
sso	string	query	No

Response

Restituisce: VoteDeleteResponse

Example

Esempio delete_comment_vote

Copy

import client
from client.api.public_api import DeleteCommentVoteOptions
from client.models.vote_delete_response import VoteDeleteResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.delete_comment_vote(tenant_id, comment_id, vote_id, url_id, broadcast_id, DeleteCommentVoteOptions(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)

segnala_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
id	string	path	Sì
userId	string	query	No
anonUserId	string	query	No

Risposta

Restituisce: FlagCommentResponse

Esempio

flag_comment Esempio

Copy

import client
from client.api.default_api import FlagCommentOptions
from client.models.flag_comment_response import FlagCommentResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    user_id = 'user_id_example' # str |  (optional)
    anon_user_id = 'anon_user_id_example' # str |  (optional)
    try:
        api_response = api_instance.flag_comment(tenant_id, id, FlagCommentOptions(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)

ottieni_commento

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: APIGetCommentResponse

Esempio

Esempio di get_comment

Copy

import client
from client.models.api_get_comment_response import APIGetCommentResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Consulta configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare il prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    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)

ottieni_testo_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Yes
commentId	string	path	Yes
editKey	string	query	No
sso	string	query	No

Risposta

Restituisce: PublicAPIGetCommentTextResponse

Esempio

Esempio get_comment_text

Copy

import client
from client.api.public_api import GetCommentTextOptions
from client.models.public_api_get_comment_text_response import PublicAPIGetCommentTextResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe 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 |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.get_comment_text(tenant_id, comment_id, GetCommentTextOptions(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)

ottieni_nomi_utenti_voto_commento

Parametri

Name	Type	Location	Required
tenantId	string	path	Sì
commentId	string	path	Sì
dir	integer	query	Sì
sso	string	query	No

Risposta

Restituisce: GetCommentVoteUserNamesSuccessResponse

Esempio

Esempio get_comment_vote_user_names

Copy

import client
from client.models.get_comment_vote_user_names_success_response import GetCommentVoteUserNamesSuccessResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e di default è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe 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 |  (opzionale)
    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)

ottieni_commenti

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
page	integer	query	No
limit	integer	query	No
skip	integer	query	No
asTree	boolean	query	No
skipChildren	integer	query	No
limitChildren	integer	query	No
maxTreeDepth	integer	query	No
urlId	string	query	No
userId	string	query	No
anonUserId	string	query	No
contextUserId	string	query	No
hashTag	string	query	No
parentId	string	query	No
direction	string	query	No
fromDate	integer	query	No
toDate	integer	query	No

Risposta

Restituisce: APIGetCommentsResponse

Esempio

Esempio get_comments

Copy

import client
from client.api.default_api import GetCommentsOptions
from client.models.api_get_comments_response import APIGetCommentsResponse
from client.models.sort_directions import SortDirections
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ciascun metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta quanto segue per impostare il prefisso (ad es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    page = 56 # int |  (optional)
    limit = 56 # int |  (optional)
    skip = 56 # int |  (optional)
    as_tree = True # bool |  (optional)
    skip_children = 56 # int |  (optional)
    limit_children = 56 # int |  (optional)
    max_tree_depth = 56 # int |  (optional)
    url_id = 'url_id_example' # str |  (optional)
    user_id = 'user_id_example' # str |  (optional)
    anon_user_id = 'anon_user_id_example' # str |  (optional)
    context_user_id = 'context_user_id_example' # str |  (optional)
    hash_tag = 'hash_tag_example' # str |  (optional)
    parent_id = 'parent_id_example' # str |  (optional)
    direction = client.SortDirections() # SortDirections |  (optional)
    from_date = 56 # int |  (optional)
    to_date = 56 # int |  (optional)
    try:
        api_response = api_instance.get_comments(tenant_id, GetCommentsOptions(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, from_date=from_date, to_date=to_date))
        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)

ottieni_commenti_pubblici

req tenantId urlId

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Yes
urlId	string	query	Yes
page	integer	query	No
direction	string	query	No
sso	string	query	No
skip	integer	query	No
skipChildren	integer	query	No
limit	integer	query	No
limitChildren	integer	query	No
countChildren	boolean	query	No
fetchPageForCommentId	string	query	No
includeConfig	boolean	query	No
countAll	boolean	query	No
includei10n	boolean	query	No
locale	string	query	No
modules	string	query	No
isCrawler	boolean	query	No
includeNotificationCount	boolean	query	No
asTree	boolean	query	No
maxTreeDepth	integer	query	No
useFullTranslationIds	boolean	query	No
parentId	string	query	No
searchText	string	query	No
hashTags	array	query	No
userId	string	query	No
customConfigStr	string	query	No
afterCommentId	string	query	No
beforeCommentId	string	query	No

Risposta

Restituisce: GetCommentsResponseWithPresencePublicComment

Esempio

Esempio get_comments_public

Copy

import client
from client.api.public_api import GetCommentsPublicOptions
from client.models.get_comments_response_with_presence_public_comment import GetCommentsResponseWithPresencePublicComment
from client.models.sort_directions import SortDirections
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    page = 56 # int |  (optional)
    direction = client.SortDirections() # SortDirections |  (optional)
    sso = 'sso_example' # str |  (optional)
    skip = 56 # int |  (optional)
    skip_children = 56 # int |  (optional)
    limit = 56 # int |  (optional)
    limit_children = 56 # int |  (optional)
    count_children = True # bool |  (optional)
    fetch_page_for_comment_id = 'fetch_page_for_comment_id_example' # str |  (optional)
    include_config = True # bool |  (optional)
    count_all = True # bool |  (optional)
    includei10n = True # bool |  (optional)
    locale = 'locale_example' # str |  (optional)
    modules = 'modules_example' # str |  (optional)
    is_crawler = True # bool |  (optional)
    include_notification_count = True # bool |  (optional)
    as_tree = True # bool |  (optional)
    max_tree_depth = 56 # int |  (optional)
    use_full_translation_ids = True # bool |  (optional)
    parent_id = 'parent_id_example' # str |  (optional)
    search_text = 'search_text_example' # str |  (optional)
    hash_tags = ['hash_tags_example'] # List[str] |  (optional)
    user_id = 'user_id_example' # str |  (optional)
    custom_config_str = 'custom_config_str_example' # str |  (optional)
    after_comment_id = 'after_comment_id_example' # str |  (optional)
    before_comment_id = 'before_comment_id_example' # str |  (optional)
    try:
        api_response = api_instance.get_comments_public(tenant_id, url_id, GetCommentsPublicOptions(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)

blocca_commento

Parametri

Name	Type	Location	Required
tenantId	string	path	Sì
commentId	string	path	Sì
broadcastId	string	query	Sì
sso	string	query	No

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di lock_comment

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e predefinita su https://fastcomments.com
# Consultare configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe 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 |  (optional)
    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)

fissa_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Sì
commentId	string	path	Sì
broadcastId	string	query	Sì
sso	string	query	No

Risposta

Restituisce: ChangeCommentPinStatusResponse

Esempio

Esempio pin_comment

Copy

import client
from client.models.change_comment_pin_status_response import ChangeCommentPinStatusResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (optional)
    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)

salva_commento

Parametri

Name	Type	Location	Required
tenantId	string	query	Yes
isLive	boolean	query	No
doSpamCheck	boolean	query	No
sendEmails	boolean	query	No
populateNotifications	boolean	query	No

Risposta

Returns: APISaveCommentResponse

Esempio

Esempio save_comment

Copy

import client
from client.api.default_api import SaveCommentOptions
from client.models.api_save_comment_response import APISaveCommentResponse
from client.models.create_comment_params import CreateCommentParams
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per l'API key, se necessario
# 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 | 
    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, SaveCommentOptions(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)

salva_commenti_bulk

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
isLive	boolean	query	No
doSpamCheck	boolean	query	No
sendEmails	boolean	query	No
populateNotifications	boolean	query	No

Risposta

Restituisce: SaveCommentsBulkResponse

Esempio

save_comments_bulk Esempio

Copy

import client
from client.api.default_api import SaveCommentsBulkOptions
from client.models.create_comment_params import CreateCommentParams
from client.models.save_comments_bulk_response import SaveCommentsBulkResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, utilizza l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta sotto per impostare il prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    create_comment_params = [client.CreateCommentParams()] # List[CreateCommentParams] | 
    is_live = True # bool |  (facoltativo)
    do_spam_check = True # bool |  (facoltativo)
    send_emails = True # bool |  (facoltativo)
    populate_notifications = True # bool |  (facoltativo)
    try:
        api_response = api_instance.save_comments_bulk(tenant_id, create_comment_params, SaveCommentsBulkOptions(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)

imposta_testo_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Yes
commentId	string	path	Yes
broadcastId	string	query	Yes
editKey	string	query	No
sso	string	query	No

Risposta

Restituisce: PublicAPISetCommentTextResponse

Esempio

Esempio set_comment_text

Copy

import client
from client.api.public_api import SetCommentTextOptions
from client.models.comment_text_update_request import CommentTextUpdateRequest
from client.models.public_api_set_comment_text_response import PublicAPISetCommentTextResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe 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 |  # (opzionale)
    sso = 'sso_example' # str |  # (opzionale)
    try:
        api_response = api_instance.set_comment_text(tenant_id, comment_id, broadcast_id, comment_text_update_request, SetCommentTextOptions(edit_key=edit_key, sso=sso))
        print("The response of PublicApi->set_comment_text:\n")
        pprint(api_response)
    except Exception as e:
        # Eccezione durante la chiamata a PublicApi->set_comment_text: %s\n
        print("Exception when calling PublicApi->set_comment_text: %s\n" % e)

sblocca_utente_da_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
id	string	path	Sì
userId	string	query	No
anonUserId	string	query	No

Risposta

Restituisce: UnblockSuccess

Esempio

un_block_user_from_comment Esempio

Copy

import client
from client.api.default_api import UnBlockUserFromCommentOptions
from client.models.un_block_from_comment_params import UnBlockFromCommentParams
from client.models.unblock_success import UnblockSuccess
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione della chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (opzionale)
    anon_user_id = 'anon_user_id_example' # str |  (opzionale)
    try:
        api_response = api_instance.un_block_user_from_comment(tenant_id, id, un_block_from_comment_params, UnBlockUserFromCommentOptions(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)

rimuovi_segnalazione_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
id	string	path	Sì
userId	string	query	No
anonUserId	string	query	No

Risposta

Restituisce: FlagCommentResponse

Esempio

Esempio un_flag_comment

Copy

import client
from client.api.default_api import UnFlagCommentOptions
from client.models.flag_comment_response import FlagCommentResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommentare quanto segue per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    user_id = 'user_id_example' # str |  (optional)
    anon_user_id = 'anon_user_id_example' # str |  (optional)
    try:
        api_response = api_instance.un_flag_comment(tenant_id, id, UnFlagCommentOptions(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)

sblocca_commento

Parametri

Nome	Tipo	Location	Obbligatorio
tenantId	string	path	Sì
commentId	string	path	Sì
broadcastId	string	query	Sì
sso	string	query	No

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di un_lock_comment

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe 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 |  (opzionale)
    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)

rimuovi_fissaggio_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Sì
commentId	string	path	Sì
broadcastId	string	query	Sì
sso	string	query	No

Risposta

Restituisce: ChangeCommentPinStatusResponse

Esempio

Esempio di un_pin_comment

Copy

import client
from client.models.change_comment_pin_status_response import ChangeCommentPinStatusResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Apri un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (opzionale)
    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)

aggiorna_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
id	string	path	Sì
contextUserId	string	query	No
doSpamCheck	boolean	query	No
isLive	boolean	query	No

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di update_comment

Copy

import client
from client.api.default_api import UpdateCommentOptions
from client.models.api_empty_response import APIEmptyResponse
from client.models.updatable_comment_params import UpdatableCommentParams
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e predefinito su https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ciascun metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# 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 | 
    updatable_comment_params = client.UpdatableCommentParams() # UpdatableCommentParams | 
    context_user_id = 'context_user_id_example' # str |  (opzionale)
    do_spam_check = True # bool |  (opzionale)
    is_live = True # bool |  (opzionale)
    try:
        api_response = api_instance.update_comment(tenant_id, id, updatable_comment_params, UpdateCommentOptions(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)

vota_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Yes
commentId	string	path	Yes
urlId	string	query	Yes
broadcastId	string	query	Yes
sessionId	string	query	No
sso	string	query	No

Risposta

Restituisce: VoteResponse

Esempio

vote_comment Esempio

Copy

import client
from client.api.public_api import VoteCommentOptions
from client.models.vote_body_params import VoteBodyParams
from client.models.vote_response import VoteResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Consulta configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.vote_comment(tenant_id, comment_id, url_id, broadcast_id, vote_body_params, VoteCommentOptions(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)

ottieni_commenti_per_utente

Parametri

Nome	Tipo	Posizione	Obbligatorio
userId	string	query	No
direction	string	query	No
repliesToUserId	string	query	No
page	number	query	No
includei10n	boolean	query	No
locale	string	query	No
isCrawler	boolean	query	No

Risposta

Restituisce: GetCommentsForUserResponse

Esempio

Esempio get_comments_for_user

Copy

import client
from client.api.public_api import GetCommentsForUserOptions
from client.models.get_comments_for_user_response import GetCommentsForUserResponse
from client.models.sort_directions import SortDirections
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e predefinito a https://fastcomments.com
# Vedere configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Aprire un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    user_id = 'user_id_example' # str |  (opzionale)
    direction = client.SortDirections() # SortDirections |  (opzionale)
    replies_to_user_id = 'replies_to_user_id_example' # str |  (opzionale)
    page = 3.4 # float |  (opzionale)
    includei10n = True # bool |  (opzionale)
    locale = 'locale_example' # str |  (opzionale)
    is_crawler = True # bool |  (opzionale)
    try:
        api_response = api_instance.get_comments_for_user(GetCommentsForUserOptions(user_id=user_id, direction=direction, replies_to_user_id=replies_to_user_id, page=page, includei10n=includei10n, locale=locale, is_crawler=is_crawler))
        print("La risposta di PublicApi->get_comments_for_user:\n")
        pprint(api_response)
    except Exception as e:
        print("Eccezione durante la chiamata a PublicApi->get_comments_for_user: %s\n" % e)

aggiungi_configurazione_dominio

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì

Risposta

Restituisce: AddDomainConfigResponse

Esempio

Esempio di add_domain_config

Copy

import client
from client.models.add_domain_config_params import AddDomainConfigParams
from client.models.add_domain_config_response import AddDomainConfigResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti qui sotto, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Rimuovi il commento qui sotto per impostare un prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

elimina_configurazione_dominio

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Yes
domain	string	path	Yes

Risposta

Restituisce: DeleteDomainConfigResponse

Esempio

Esempio di delete_domain_config

Copy

import client
from client.models.delete_domain_config_response import DeleteDomainConfigResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti qui sotto, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Rimuovi il commento qui sotto per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_configurazione_dominio

Parametri

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

Risposta

Restituisce: GetDomainConfigResponse

Esempio

Esempio di get_domain_config

Copy

import client
from client.models.get_domain_config_response import GetDomainConfigResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autenticazione con API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_configurazioni_dominio

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì

Risposta

Restituisce: GetDomainConfigsResponse

Esempio

Esempio get_domain_configs

Copy

import client
from client.models.get_domain_configs_response import GetDomainConfigsResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare il prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

modifica_configurazione_dominio

Parametri

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

Risposta

Restituisce: PatchDomainConfigResponse

Esempio

Esempio di patch_domain_config

Copy

import client
from client.models.patch_domain_config_params import PatchDomainConfigParams
from client.models.patch_domain_config_response import PatchDomainConfigResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e di default è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Sono forniti esempi per ogni metodo di auth qui sotto; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta sotto per impostare il prefisso (es. Bearer) per API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

imposta_configurazione_dominio

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
domainToUpdate	string	path	Sì

Risposta

Restituisce: PutDomainConfigResponse

Esempio

Esempio di put_domain_config

Copy

import client
from client.models.put_domain_config_response import PutDomainConfigResponse
from client.models.update_domain_config_params import UpdateDomainConfigParams
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono mostrati esempi per ogni metodo di autenticazione; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autenticazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Rimuovi il commento qui sotto per impostare il prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

crea_modello_email

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì

Risposta

Restituisce: CreateEmailTemplateResponse

Esempio

Esempio di create_email_template

Copy

import client
from client.models.create_email_template_body import CreateEmailTemplateBody
from client.models.create_email_template_response import CreateEmailTemplateResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Sono forniti esempi per ogni metodo di autenticazione qui sotto; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sotto per impostare il prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

elimina_modello_email

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di delete_email_template

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# conformemente alla policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (ad es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

elimina_errore_render_modello_email

Parametri

Name	Type	Location	Required
tenantId	string	query	Sì
id	string	path	Sì
errorId	string	path	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di delete_email_template_render_error

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedere configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autenticazione tramite chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare un prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_modello_email

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: GetEmailTemplateResponse

Esempio

Esempio di get_email_template

Copy

import client
from client.models.get_email_template_response import GetEmailTemplateResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_definizioni_modello_email

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì

Risposta

Restituisce: GetEmailTemplateDefinitionsResponse

Esempio

Esempio di get_email_template_definitions

Copy

import client
from client.models.get_email_template_definitions_response import GetEmailTemplateDefinitionsResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_errori_render_modello_email

Parametri

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

Risposta

Restituisce: GetEmailTemplateRenderErrorsResponse

Esempio

Esempio get_email_template_render_errors

Copy

import client
from client.models.get_email_template_render_errors_response import GetEmailTemplateRenderErrorsResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ciascun metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# 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'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    skip = 3.4 # float |  (opzionale)
    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)

ottieni_modelli_email

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
skip	number	query	No

Risposta

Restituisce: GetEmailTemplatesResponse

Esempio

Esempio get_email_templates

Copy

import client
from client.models.get_email_templates_response import GetEmailTemplatesResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e impostato di default su https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità alla policy di sicurezza del server API.
# Di seguito sono forniti esempi per ciascun metodo di auth, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta sotto per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

renderizza_modello_email

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì
locale	string	query	No

Risposta

Restituisce: RenderEmailTemplateResponse

Esempio

Esempio di render_email_template

Copy

import client
from client.models.render_email_template_body import RenderEmailTemplateBody
from client.models.render_email_template_response import RenderEmailTemplateResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta sotto per impostare il prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    render_email_template_body = client.RenderEmailTemplateBody() # RenderEmailTemplateBody | 
    locale = 'locale_example' # str |  (optional)
    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)

aggiorna_modello_email

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di update_email_template

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.models.update_email_template_body import UpdateEmailTemplateBody
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configurare l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommentare la riga sotto per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe 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)

ottieni_registro_eventi

req tenantId urlId userIdWS

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Sì
urlId	string	query	Sì
userIdWS	string	query	Sì
startTime	integer	query	Sì
endTime	integer	query	No

Risposta

Restituisce: GetEventLogResponse

Esempio

Esempio di get_event_log

Copy

import client
from client.models.get_event_log_response import GetEventLogResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (optional)
    try:
        api_response = api_instance.get_event_log(tenant_id, url_id, user_id_ws, start_time, end_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)

ottieni_registro_eventi_globale

req tenantId urlId userIdWS

Parametri

Nome	Tipo	Posizione	Richiesto
tenantId	string	path	Sì
urlId	string	query	Sì
userIdWS	string	query	Sì
startTime	integer	query	Sì
endTime	integer	query	No

Risposta

Restituisce: GetEventLogResponse

Esempio

Esempio get_global_event_log

Copy

import client
from client.models.get_event_log_response import GetEventLogResponse
from client.rest import ApiException
from pprint import pprint
# L'impostazione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Consulta configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (opzionale)
    try:
        api_response = api_instance.get_global_event_log(tenant_id, url_id, user_id_ws, start_time, end_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)

crea_post_feed

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
broadcastId	string	query	No
isLive	boolean	query	No
doSpamCheck	boolean	query	No
skipDupCheck	boolean	query	No

Risposta

Restituisce: CreateFeedPostsResponse

Esempio

Esempio create_feed_post

Copy

import client
from client.api.default_api import CreateFeedPostOptions
from client.models.create_feed_post_params import CreateFeedPostParams
from client.models.create_feed_posts_response import CreateFeedPostsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ciascun metodo di autenticazione sono forniti di seguito, usare l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione della chiave API: api_key
# Decommenta sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (optional)
    is_live = True # bool |  (optional)
    do_spam_check = True # bool |  (optional)
    skip_dup_check = True # bool |  (optional)
    try:
        api_response = api_instance.create_feed_post(tenant_id, create_feed_post_params, CreateFeedPostOptions(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)

crea_post_feed_pubblico

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Sì
broadcastId	string	query	No
sso	string	query	No

Risposta

Restituisce: CreateFeedPostResponse

Esempio

create_feed_post_public Esempio

Copy

import client
from client.api.public_api import CreateFeedPostPublicOptions
from client.models.create_feed_post_params import CreateFeedPostParams
from client.models.create_feed_post_response import CreateFeedPostResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e predefinito a https://fastcomments.com
# Consulta configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.create_feed_post_public(tenant_id, create_feed_post_params, CreateFeedPostPublicOptions(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)

elimina_post_feed_pubblico

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Yes
postId	string	path	Yes
broadcastId	string	query	No
sso	string	query	No

Risposta

Restituisce: DeleteFeedPostPublicResponse

Esempio

Esempio delete_feed_post_public

Copy

import client
from client.api.public_api import DeleteFeedPostPublicOptions
from client.models.delete_feed_post_public_response import DeleteFeedPostPublicResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe 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 |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.delete_feed_post_public(tenant_id, post_id, DeleteFeedPostPublicOptions(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)

ottieni_post_feed

req tenantId afterId

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
afterId	string	query	No
limit	integer	query	No
tags	array	query	No

Risposta

Restituisce: GetFeedPostsResponse

Esempio

Esempio get_feed_posts

Copy

import client
from client.api.default_api import GetFeedPostsOptions
from client.models.get_feed_posts_response import GetFeedPostsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione della chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (ad es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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, GetFeedPostsOptions(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)

ottieni_post_feed_pubblici

req tenantId afterId

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Sì
afterId	string	query	No
limit	integer	query	No
tags	array	query	No
sso	string	query	No
isCrawler	boolean	query	No
includeUserInfo	boolean	query	No

Risposta

Restituisce: PublicFeedPostsResponse

Esempio

Esempio get_feed_posts_public

Copy

import client
from client.api.public_api import GetFeedPostsPublicOptions
from client.models.public_feed_posts_response import PublicFeedPostsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e di default è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.PublicApi(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)
    sso = 'sso_example' # str |  (optional)
    is_crawler = True # bool |  (optional)
    include_user_info = True # bool |  (optional)
    try:
        api_response = api_instance.get_feed_posts_public(tenant_id, GetFeedPostsPublicOptions(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)

ottieni_statistiche_post_feed

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Sì
postIds	array	query	Sì
sso	string	query	No

Risposta

Restituisce: FeedPostsStatsResponse

Esempio

Esempio di get_feed_posts_stats

Copy

import client
from client.models.feed_posts_stats_response import FeedPostsStatsResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e di default è https://fastcomments.com
# Consultare configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    post_ids = ['post_ids_example'] # List[str] | 
    sso = 'sso_example' # str |  (optional)
    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)

ottieni_reazioni_utente_pubbliche

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Sì
postIds	array	query	No
sso	string	query	No

Risposta

Restituisce: UserReactsResponse

Esempio

Esempio get_user_reacts_public

Copy

import client
from client.api.public_api import GetUserReactsPublicOptions
from client.models.user_reacts_response import UserReactsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    post_ids = ['post_ids_example'] # List[str] |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.get_user_reacts_public(tenant_id, GetUserReactsPublicOptions(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)

reagisci_post_feed_pubblico

Parameters

Name	Type	Location	Required
tenantId	string	path	Yes
postId	string	path	Yes
isUndo	boolean	query	No
broadcastId	string	query	No
sso	string	query	No

Response

Restituisce: ReactFeedPostResponse

Example

react_feed_post_public Esempio

Copy

import client
from client.api.public_api import ReactFeedPostPublicOptions
from client.models.react_body_params import ReactBodyParams
from client.models.react_feed_post_response import ReactFeedPostResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (optional)
    broadcast_id = 'broadcast_id_example' # str |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.react_feed_post_public(tenant_id, post_id, react_body_params, ReactFeedPostPublicOptions(is_undo=is_undo, broadcast_id=broadcast_id, sso=sso))
        print("La risposta di PublicApi->react_feed_post_public:\n")
        pprint(api_response)
    except Exception as e:
        print("Eccezione durante la chiamata a PublicApi->react_feed_post_public: %s\n" % e)

aggiorna_post_feed

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di update_feed_post

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.models.feed_post import FeedPost
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e predefinita a https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta quanto segue per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

aggiorna_post_feed_pubblico

Parametri

Name	Type	Location	Required
tenantId	string	path	Yes
postId	string	path	Yes
broadcastId	string	query	No
sso	string	query	No

Risposta

Restituisce: CreateFeedPostResponse

Esempio

Esempio di update_feed_post_public

Copy

import client
from client.api.public_api import UpdateFeedPostPublicOptions
from client.models.create_feed_post_response import CreateFeedPostResponse
from client.models.update_feed_post_params import UpdateFeedPostParams
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe 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 |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.update_feed_post_public(tenant_id, post_id, update_feed_post_params, UpdateFeedPostPublicOptions(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)

segnala_commento_pubblico

Parametri

Name	Type	Location	Required
tenantId	string	query	Sì
commentId	string	path	Sì
isFlagged	boolean	query	Sì
sso	string	query	No

Risposta

Restituisce: APIEmptyResponse

Esempio

flag_comment_public Esempio

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_gif_grande

Parametri

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

Risposta

Restituisce: GifGetLargeResponse

Esempio

Esempio get_gif_large

Copy

import client
from client.models.gif_get_large_response import GifGetLargeResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e per default è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    large_internal_url_sanitized = 'large_internal_url_sanitized_example' # str | 
    try:
        api_response = api_instance.get_gif_large(tenant_id, large_internal_url_sanitized)
        print("The response of PublicApi->get_gif_large:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_gif_large: %s\n" % e)

cerca_gif

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Sì
search	string	query	Sì
locale	string	query	No
rating	string	query	No
page	number	query	No

Risposta

Restituisce: GetGifsSearchResponse

Esempio

Esempio get_gifs_search

Copy

import client
from client.api.public_api import GetGifsSearchOptions
from client.models.get_gifs_search_response import GetGifsSearchResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    search = 'search_example' # str | 
    locale = 'locale_example' # str |  (opzionale)
    rating = 'rating_example' # str |  (opzionale)
    page = 3.4 # float |  (opzionale)
    try:
        api_response = api_instance.get_gifs_search(tenant_id, search, GetGifsSearchOptions(locale=locale, rating=rating, page=page))
        print("The response of PublicApi->get_gifs_search:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_gifs_search: %s\n" % e)

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Yes
locale	string	query	No
rating	string	query	No
page	number	query	No

Risposta

Restituisce: GetGifsTrendingResponse

Esempio

Esempio get_gifs_trending

Copy

import client
from client.api.public_api import GetGifsTrendingOptions
from client.models.get_gifs_trending_response import GetGifsTrendingResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Consulta configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    locale = 'locale_example' # str |  (optional)
    rating = 'rating_example' # str |  (optional)
    page = 3.4 # float |  (optional)
    try:
        api_response = api_instance.get_gifs_trending(tenant_id, GetGifsTrendingOptions(locale=locale, rating=rating, page=page))
        print("The response of PublicApi->get_gifs_trending:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_gifs_trending: %s\n" % e)

aggiungi_tag_hash

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Yes

Risposta

Restituisce: CreateHashTagResponse

Esempio

add_hash_tag Esempio

Copy

import client
from client.models.create_hash_tag_body import CreateHashTagBody
from client.models.create_hash_tag_response import CreateHashTagResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e di default è https://fastcomments.com
# Vedere configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
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 | 
    create_hash_tag_body = client.CreateHashTagBody() # CreateHashTagBody |  (optional)
    try:
        api_response = api_instance.add_hash_tag(tenant_id, 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)

aggiungi_tag_hash_bulk

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì

Risposta

Restituisce: BulkCreateHashTagsResponse

Esempio

add_hash_tags_bulk Esempio

Copy

import client
from client.models.bulk_create_hash_tags_body import BulkCreateHashTagsBody
from client.models.bulk_create_hash_tags_response import BulkCreateHashTagsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Rimuovi il commento qui sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    bulk_create_hash_tags_body = client.BulkCreateHashTagsBody() # BulkCreateHashTagsBody |  (optional)
    try:
        api_response = api_instance.add_hash_tags_bulk(tenant_id, 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)

elimina_tag_hash

Parameters

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
tag	string	path	Sì

Response

Restituisce: APIEmptyResponse

Example

delete_hash_tag Esempio

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.models.delete_hash_tag_request_body import DeleteHashTagRequestBody
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e di default è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti sotto, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione della chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (ad esempio Bearer) per la chiave API, se necessario
# 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 | 
    tag = 'tag_example' # str | 
    delete_hash_tag_request_body = client.DeleteHashTagRequestBody() # DeleteHashTagRequestBody |  (optional)
    try:
        api_response = api_instance.delete_hash_tag(tenant_id, tag, delete_hash_tag_request_body)
        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)

ottieni_tag_hash

Parametri

Nome	Tipo	Posizione	Richiesto	Descrizione
tenantId	string	query	Sì
page	number	query	No

Risposta

Restituisce: GetHashTagsResponse

Esempio

Esempio di get_hash_tags

Copy

import client
from client.models.get_hash_tags_response import GetHashTagsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta sotto per impostare un prefisso (es. Bearer) per api_key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    page = 3.4 # float |  (opzionale)
    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)

modifica_tag_hash

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Yes
tag	string	path	Yes

Risposta

Restituisce: UpdateHashTagResponse

Esempio

patch_hash_tag Esempio

Copy

import client
from client.models.update_hash_tag_body import UpdateHashTagBody
from client.models.update_hash_tag_response import UpdateHashTagResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per l'elenco di tutti i parametri di configurazione supportati.
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione della chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta quanto segue per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    tag = 'tag_example' # str | 
    update_hash_tag_body = client.UpdateHashTagBody() # UpdateHashTagBody |  (optional)
    try:
        api_response = api_instance.patch_hash_tag(tenant_id, tag, 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)

elimina_voto_moderazione

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
commentId	string	path	Sì
voteId	string	path	Sì
broadcastId	string	query	No
sso	string	query	No

Risposta

Restituisce: VoteDeleteResponse

Esempio

delete_moderation_vote Esempio

Copy

import client
from client.api.moderation_api import DeleteModerationVoteOptions
from client.models.vote_delete_response import VoteDeleteResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    vote_id = 'vote_id_example' # str | 
    broadcast_id = 'broadcast_id_example' # str |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.delete_moderation_vote(tenant_id, comment_id, vote_id, DeleteModerationVoteOptions(broadcast_id=broadcast_id, sso=sso))
        print("The response of ModerationApi->delete_moderation_vote:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->delete_moderation_vote: %s\n" % e)

ottieni_commenti_api

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
page	number	query	No
count	number	query	No
text-search	string	query	No
byIPFromComment	string	query	No
filters	string	query	No
searchFilters	string	query	No
sorts	string	query	No
demo	boolean	query	No
sso	string	query	No

Risposta

Restituisce: ModerationAPIGetCommentsResponse

Esempio

get_api_comments Esempio

Copy

import client
from client.api.moderation_api import GetApiCommentsOptions
from client.models.moderation_api_get_comments_response import ModerationAPIGetCommentsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    page = 3.4 # float |  (optional)
    count = 3.4 # float |  (optional)
    text_search = 'text_search_example' # str |  (optional)
    by_ip_from_comment = 'by_ip_from_comment_example' # str |  (optional)
    filters = 'filters_example' # str |  (optional)
    search_filters = 'search_filters_example' # str |  (optional)
    sorts = 'sorts_example' # str |  (optional)
    demo = True # bool |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.get_api_comments(tenant_id, GetApiCommentsOptions(page=page, count=count, text_search=text_search, by_ip_from_comment=by_ip_from_comment, filters=filters, search_filters=search_filters, sorts=sorts, demo=demo, sso=sso))
        print("La risposta di ModerationApi->get_api_comments:\n")
        pprint(api_response)
    except Exception as e:
        print("Eccezione durante la chiamata a ModerationApi->get_api_comments: %s\n" % e)

ottieni_stato_esportazione_api

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
batchJobId	string	query	No
sso	string	query	No

Risposta

Restituisce: ModerationExportStatusResponse

Esempio

Esempio get_api_export_status

Copy

import client
from client.api.moderation_api import GetApiExportStatusOptions
from client.models.moderation_export_status_response import ModerationExportStatusResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    batch_job_id = 'batch_job_id_example' # str |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.get_api_export_status(tenant_id, GetApiExportStatusOptions(batch_job_id=batch_job_id, sso=sso))
        print("The response of ModerationApi->get_api_export_status:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_api_export_status: %s\n" % e)

ottieni_id_api

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
text-search	string	query	No
byIPFromComment	string	query	No
filters	string	query	No
searchFilters	string	query	No
afterId	string	query	No
demo	boolean	query	No
sso	string	query	No

Risposta

Restituisce: ModerationAPIGetCommentIdsResponse

Esempio

Esempio get_api_ids

Copy

import client
from client.api.moderation_api import GetApiIdsOptions
from client.models.moderation_api_get_comment_ids_response import ModerationAPIGetCommentIdsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    text_search = 'text_search_example' # str |  (optional)
    by_ip_from_comment = 'by_ip_from_comment_example' # str |  (optional)
    filters = 'filters_example' # str |  (optional)
    search_filters = 'search_filters_example' # str |  (optional)
    after_id = 'after_id_example' # str |  (optional)
    demo = True # bool |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.get_api_ids(tenant_id, GetApiIdsOptions(text_search=text_search, by_ip_from_comment=by_ip_from_comment, filters=filters, search_filters=search_filters, after_id=after_id, demo=demo, sso=sso))
        print("The response of ModerationApi->get_api_ids:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_api_ids: %s\n" % e)

ottieni_utenti_bannati_da_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
commentId	string	path	Yes
sso	string	query	No

Risposta

Restituisce: GetBannedUsersFromCommentResponse

Esempio

Esempio get_ban_users_from_comment

Copy

import client
from client.models.get_banned_users_from_comment_response import GetBannedUsersFromCommentResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Consulta configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.get_ban_users_from_comment(tenant_id, comment_id, sso=sso)
        print("The response of ModerationApi->get_ban_users_from_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_ban_users_from_comment: %s\n" % e)

ottieni_stato_ban_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
commentId	string	path	Yes
sso	string	query	No

Risposta

Restituisce: GetCommentBanStatusResponse

Esempio

Esempio get_comment_ban_status

Copy

import client
from client.models.get_comment_ban_status_response import GetCommentBanStatusResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Consulta configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.get_comment_ban_status(tenant_id, comment_id, sso=sso)
        print("The response of ModerationApi->get_comment_ban_status:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_comment_ban_status: %s\n" % e)

ottieni_figli_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
commentId	string	path	Sì
sso	string	query	No

Risposta

Restituisce: ModerationAPIChildCommentsResponse

Esempio

Esempio get_comment_children

Copy

import client
from client.models.moderation_api_child_comments_response import ModerationAPIChildCommentsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.get_comment_children(tenant_id, comment_id, sso=sso)
        print("The response of ModerationApi->get_comment_children:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_comment_children: %s\n" % e)

ottieni_conteggio

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
text-search	string	query	No
byIPFromComment	string	query	No
filter	string	query	No
searchFilters	string	query	No
demo	boolean	query	No
sso	string	query	No

Risposta

Restituisce: ModerationAPICountCommentsResponse

Esempio

Esempio get_count

Copy

import client
from client.api.moderation_api import GetCountOptions
from client.models.moderation_api_count_comments_response import ModerationAPICountCommentsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    text_search = 'text_search_example' # str |  (opzionale)
    by_ip_from_comment = 'by_ip_from_comment_example' # str |  (opzionale)
    filter = 'filter_example' # str |  (opzionale)
    search_filters = 'search_filters_example' # str |  (opzionale)
    demo = True # bool |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.get_count(tenant_id, GetCountOptions(text_search=text_search, by_ip_from_comment=by_ip_from_comment, filter=filter, search_filters=search_filters, demo=demo, sso=sso))
        print("La risposta di ModerationApi->get_count:\n")
        pprint(api_response)
    except Exception as e:
        print("Eccezione durante la chiamata a ModerationApi->get_count: %s\n" % e)

ottieni_conteggi

Parameters

Name	Type	Location	Required	Description
tenantId	string	query	Sì
sso	string	query	No

Response

Restituisce: GetBannedUsersCountResponse

Example

Esempio get_counts

Copy

import client
from client.models.get_banned_users_count_response import GetBannedUsersCountResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito su https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.get_counts(tenant_id, sso=sso)
        print("The response of ModerationApi->get_counts:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_counts: %s\n" % e)

ottieni_log

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
commentId	string	path	Yes
sso	string	query	No

Risposta

Returns: ModerationAPIGetLogsResponse

Esempio

Esempio get_logs

Copy

import client
from client.models.moderation_api_get_logs_response import ModerationAPIGetLogsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.get_logs(tenant_id, comment_id, sso=sso)
        print("The response of ModerationApi->get_logs:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_logs: %s\n" % e)

ottieni_badge_manuali

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
sso	string	query	No

Risposta

Restituisce: GetTenantManualBadgesResponse

Esempio

get_manual_badges Esempio

Copy

import client
from client.models.get_tenant_manual_badges_response import GetTenantManualBadgesResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.get_manual_badges(tenant_id, sso=sso)
        print("The response of ModerationApi->get_manual_badges:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_manual_badges: %s\n" % e)

ottieni_badge_manuali_per_utente

Parametri

Name	Type	Location	Required
tenantId	string	query	Sì
badgesUserId	string	query	No
commentId	string	query	No
sso	string	query	No

Risposta

Restituisce: GetUserManualBadgesResponse

Esempio

get_manual_badges_for_user Esempio

Copy

import client
from client.api.moderation_api import GetManualBadgesForUserOptions
from client.models.get_user_manual_badges_response import GetUserManualBadgesResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    badges_user_id = 'badges_user_id_example' # str |  (opzionale)
    comment_id = 'comment_id_example' # str |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.get_manual_badges_for_user(tenant_id, GetManualBadgesForUserOptions(badges_user_id=badges_user_id, comment_id=comment_id, sso=sso))
        print("The response of ModerationApi->get_manual_badges_for_user:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_manual_badges_for_user: %s\n" % e)

ottieni_commento_moderazione

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
commentId	string	path	Sì
includeEmail	boolean	query	No
includeIP	boolean	query	No
sso	string	query	No

Risposta

Restituisce: ModerationAPICommentResponse

Esempio

Esempio get_moderation_comment

Copy

import client
from client.api.moderation_api import GetModerationCommentOptions
from client.models.moderation_api_comment_response import ModerationAPICommentResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    include_email = True # bool |  (opzionale)
    include_ip = True # bool |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.get_moderation_comment(tenant_id, comment_id, GetModerationCommentOptions(include_email=include_email, include_ip=include_ip, sso=sso))
        print("The response of ModerationApi->get_moderation_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_moderation_comment: %s\n" % e)

ottieni_testo_commento_moderazione

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
commentId	string	path	Sì
sso	string	query	No

Risposta

Restituisce: GetCommentTextResponse

Esempio

get_moderation_comment_text Esempio

Copy

import client
from client.models.get_comment_text_response import GetCommentTextResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.get_moderation_comment_text(tenant_id, comment_id, sso=sio)
        print("The response of ModerationApi->get_moderation_comment_text:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_moderation_comment_text: %s\n" % e)

ottieni_riepilogo_pre_ban

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
commentId	string	path	Sì
includeByUserIdAndEmail	boolean	query	No
includeByIP	boolean	query	No
includeByEmailDomain	boolean	query	No
sso	string	query	No

Risposta

Restituisce: PreBanSummary

Esempio

get_pre_ban_summary Esempio

Copy

import client
from client.api.moderation_api import GetPreBanSummaryOptions
from client.models.pre_ban_summary import PreBanSummary
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Consulta configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    include_by_user_id_and_email = True # bool |  (optional)
    include_by_ip = True # bool |  (optional)
    include_by_email_domain = True # bool |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.get_pre_ban_summary(tenant_id, comment_id, GetPreBanSummaryOptions(include_by_user_id_and_email=include_by_user_id_and_email, include_by_ip=include_by_ip, include_by_email_domain=include_by_email_domain, sso=sso))
        print("The response of ModerationApi->get_pre_ban_summary:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_pre_ban_summary: %s\n" % e)

ottieni_riepilogo_ricerca_commenti

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
value	string	query	No
filters	string	query	No
searchFilters	string	query	No
sso	string	query	No

Risposta

Restituisce: ModerationCommentSearchResponse

Esempio

Esempio get_search_comments_summary

Copy

import client
from client.api.moderation_api import GetSearchCommentsSummaryOptions
from client.models.moderation_comment_search_response import ModerationCommentSearchResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e di default è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    value = 'value_example' # str |  (opzionale)
    filters = 'filters_example' # str |  (opzionale)
    search_filters = 'search_filters_example' # str |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.get_search_comments_summary(tenant_id, GetSearchCommentsSummaryOptions(value=value, filters=filters, search_filters=search_filters, sso=sso))
        print("The response of ModerationApi->get_search_comments_summary:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_search_comments_summary: %s\n" % e)

ottieni_pagine_ricerca

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
value	string	query	No
sso	string	query	No

Risposta

Restituisce: ModerationPageSearchResponse

Esempio

Esempio get_search_pages

Copy

import client
from client.api.moderation_api import GetSearchPagesOptions
from client.models.moderation_page_search_response import ModerationPageSearchResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    value = 'value_example' # str |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.get_search_pages(tenant_id, GetSearchPagesOptions(value=value, sso=sso))
        print("The response of ModerationApi->get_search_pages:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_search_pages: %s\n" % e)

ottieni_siti_ricerca

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
value	string	query	No
sso	string	query	No

Risposta

Restituisce: ModerationSiteSearchResponse

Esempio

get_search_sites Esempio

Copy

import client
from client.api.moderation_api import GetSearchSitesOptions
from client.models.moderation_site_search_response import ModerationSiteSearchResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e di default è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    value = 'value_example' # str |  (facoltativo)
    sso = 'sso_example' # str |  (facoltativo)
    try:
        api_response = api_instance.get_search_sites(tenant_id, GetSearchSitesOptions(value=value, sso=sso))
        print("The response of ModerationApi->get_search_sites:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_search_sites: %s\n" % e)

ottieni_suggerimento_ricerca

Parameters

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
text-search	string	query	No
sso	string	query	No

Response

Returns: ModerationSuggestResponse

Esempio

Esempio get_search_suggest

Copy

import client
from client.api.moderation_api import GetSearchSuggestOptions
from client.models.moderation_suggest_response import ModerationSuggestResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    text_search = 'text_search_example' # str |  (facoltativo)
    sso = 'sso_example' # str |  (facoltativo)
    try:
        api_response = api_instance.get_search_suggest(tenant_id, GetSearchSuggestOptions(text_search=text_search, sso=sso))
        print("The response of ModerationApi->get_search_suggest:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_search_suggest: %s\n" % e)

ottieni_utenti_ricerca

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
value	string	query	No
sso	string	query	No

Risposta

Restituisce: ModerationUserSearchResponse

Esempio

get_search_users Esempio

Copy

import client
from client.api.moderation_api import GetSearchUsersOptions
from client.models.moderation_user_search_response import ModerationUserSearchResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    value = 'value_example' # str |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.get_search_users(tenant_id, GetSearchUsersOptions(value=value, sso=sso))
        print("The response of ModerationApi->get_search_users:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_search_users: %s\n" % e)

ottieni_fattore_fiducia

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
userId	string	query	No
sso	string	query	No

Risposta

Restituisce: GetUserTrustFactorResponse

Esempio

Esempio get_trust_factor

Copy

import client
from client.api.moderation_api import GetTrustFactorOptions
from client.models.get_user_trust_factor_response import GetUserTrustFactorResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.get_trust_factor(tenant_id, GetTrustFactorOptions(user_id=user_id, sso=sso))
        print("The response of ModerationApi->get_trust_factor:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_trust_factor: %s\n" % e)

ottieni_preferenza_ban_utente

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
sso	string	query	No

Risposta

Restituisce: APIModerateGetUserBanPreferencesResponse

Esempio

Esempio get_user_ban_preference

Copy

import client
from client.models.api_moderate_get_user_ban_preferences_response import APIModerateGetUserBanPreferencesResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e predefinito a https://fastcomments.com
# Vedere configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.get_user_ban_preference(tenant_id, sso=sso)
        print("The response of ModerationApi->get_user_ban_preference:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_user_ban_preference: %s\n" % e)

ottieni_profilo_interno_utente

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
commentId	string	query	No
sso	string	query	No

Risposta

Returns: GetUserInternalProfileResponse

Esempio

Esempio get_user_internal_profile

Copy

import client
from client.api.moderation_api import GetUserInternalProfileOptions
from client.models.get_user_internal_profile_response import GetUserInternalProfileResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.get_user_internal_profile(tenant_id, GetUserInternalProfileOptions(comment_id=comment_id, sso=sso))
        print("The response of ModerationApi->get_user_internal_profile:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_user_internal_profile: %s\n" % e)

regola_voti_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
commentId	string	path	Sì
broadcastId	string	query	No
sso	string	query	No

Risposta

Returns: AdjustVotesResponse

Esempio

post_adjust_comment_votes Esempio

Copy

import client
from client.api.moderation_api import PostAdjustCommentVotesOptions
from client.models.adjust_comment_votes_params import AdjustCommentVotesParams
from client.models.adjust_votes_response import AdjustVotesResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    adjust_comment_votes_params = client.AdjustCommentVotesParams() # AdjustCommentVotesParams | 
    broadcast_id = 'broadcast_id_example' # str |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.post_adjust_comment_votes(tenant_id, comment_id, adjust_comment_votes_params, PostAdjustCommentVotesOptions(broadcast_id=broadcast_id, sso=sso))
        print("The response of ModerationApi->post_adjust_comment_votes:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->post_adjust_comment_votes: %s\n" % e)

esporta_api

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
text-search	string	query	No
byIPFromComment	string	query	No
filters	string	query	No
searchFilters	string	query	No
sorts	string	query	No
sso	string	query	No

Risposta

Restituisce: ModerationExportResponse

Esempio

post_api_export Esempio

Copy

import client
from client.api.moderation_api import PostApiExportOptions
from client.models.moderation_export_response import ModerationExportResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    text_search = 'text_search_example' # str |  (opzionale)
    by_ip_from_comment = 'by_ip_from_comment_example' # str |  (opzionale)
    filters = 'filters_example' # str |  (opzionale)
    search_filters = 'search_filters_example' # str |  (opzionale)
    sorts = 'sorts_example' # str |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.post_api_export(tenant_id, PostApiExportOptions(text_search=text_search, by_ip_from_comment=by_ip_from_comment, filters=filters, search_filters=search_filters, sorts=sorts, sso=sso))
        print("The response of ModerationApi->post_api_export:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->post_api_export: %s\n" % e)

banna_utente_da_commento

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
commentId	string	path	Yes
banEmail	boolean	query	No
banEmailDomain	boolean	query	No
banIP	boolean	query	No
deleteAllUsersComments	boolean	query	No
bannedUntil	string	query	No
isShadowBan	boolean	query	No
updateId	string	query	No
banReason	string	query	No
sso	string	query	No

Response

Returns: BanUserFromCommentResult

Example

post_ban_user_from_comment Esempio

Copy

import client
from client.api.moderation_api import PostBanUserFromCommentOptions
from client.models.ban_user_from_comment_result import BanUserFromCommentResult
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    ban_email = True # bool |  (optional)
    ban_email_domain = True # bool |  (optional)
    ban_ip = True # bool |  (optional)
    delete_all_users_comments = True # bool |  (optional)
    banned_until = 'banned_until_example' # str |  (optional)
    is_shadow_ban = True # bool |  (optional)
    update_id = 'update_id_example' # str |  (optional)
    ban_reason = 'ban_reason_example' # str |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.post_ban_user_from_comment(tenant_id, comment_id, PostBanUserFromCommentOptions(ban_email=ban_email, ban_email_domain=ban_email_domain, ban_ip=ban_ip, delete_all_users_comments=delete_all_users_comments, banned_until=banned_until, is_shadow_ban=is_shadow_ban, update_id=update_id, ban_reason=ban_reason, sso=sso))
        print("The response of ModerationApi->post_ban_user_from_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->post_ban_user_from_comment: %s\n" % e)

annulla_ban_utente

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Yes
sso	string	query	No

Risposta

Restituisce: APIEmptyResponse

Esempio

post_ban_user_undo Esempio

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.models.ban_user_undo_params import BanUserUndoParams
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    ban_user_undo_params = client.BanUserUndoParams() # BanUserUndoParams | 
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.post_ban_user_undo(tenant_id, ban_user_undo_params, sso=sso)
        print("The response of ModerationApi->post_ban_user_undo:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->post_ban_user_undo: %s\n" % e)

riepilogo_pre_ban_bulk

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
includeByUserIdAndEmail	boolean	query	No
includeByIP	boolean	query	No
includeByEmailDomain	boolean	query	No
sso	string	query	No

Risposta

Restituisce: BulkPreBanSummary

Esempio

post_bulk_pre_ban_summary Esempio

Copy

import client
from client.api.moderation_api import PostBulkPreBanSummaryOptions
from client.models.bulk_pre_ban_params import BulkPreBanParams
from client.models.bulk_pre_ban_summary import BulkPreBanSummary
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    bulk_pre_ban_params = client.BulkPreBanParams() # BulkPreBanParams | 
    include_by_user_id_and_email = True # bool |  (optional)
    include_by_ip = True # bool |  (optional)
    include_by_email_domain = True # bool |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.post_bulk_pre_ban_summary(tenant_id, bulk_pre_ban_params, PostBulkPreBanSummaryOptions(include_by_user_id_and_email=include_by_user_id_and_email, include_by_ip=include_by_ip, include_by_email_domain=include_by_email_domain, sso=sso))
        print("The response of ModerationApi->post_bulk_pre_ban_summary:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->post_bulk_pre_ban_summary: %s\n" % e)

commenti_per_id

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
sso	string	query	No

Risposta

Restituisce: ModerationAPIChildCommentsResponse

Esempio

post_comments_by_ids Esempio

Copy

import client
from client.models.comments_by_ids_params import CommentsByIdsParams
from client.models.moderation_api_child_comments_response import ModerationAPIChildCommentsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comments_by_ids_params = client.CommentsByIdsParams() # CommentsByIdsParams | 
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.post_comments_by_ids(tenant_id, comments_by_ids_params, sgo=sgo)
        print("The response of ModerationApi->post_comments_by_ids:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->post_comments_by_ids: %s\n" % e)

segnala_commento_post

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
commentId	string	path	Sì
broadcastId	string	query	No
sso	string	query	No

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio post_flag_comment

Copy

import client
from client.api.moderation_api import PostFlagCommentOptions
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
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.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    broadcast_id = 'broadcast_id_example' # str |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.post_flag_comment(tenant_id, comment_id, PostFlagCommentOptions(broadcast_id=broadcast_id, sso=sso))
        print("The response of ModerationApi->post_flag_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->post_flag_comment: %s\n" % e)

rimuovi_commento_post

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
commentId	string	path	Sì
broadcastId	string	query	No
sso	string	query	No

Risposta

Restituisce: PostRemoveCommentApiResponse

Esempio

post_remove_comment Esempio

Copy

import client
from client.api.moderation_api import PostRemoveCommentOptions
from client.models.post_remove_comment_api_response import PostRemoveCommentApiResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    broadcast_id = 'broadcast_id_example' # str |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.post_remove_comment(tenant_id, comment_id, PostRemoveCommentOptions(broadcast_id=broadcast_id, sso=sso))
        print("The response of ModerationApi->post_remove_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->post_remove_comment: %s\n" % e)

ripristina_commento_cancellato

Parametri

Name	Type	Location	Required
tenantId	string	query	Sì
commentId	string	path	Sì
broadcastId	string	query	No
sso	string	query	No

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio post_restore_deleted_comment

Copy

import client
from client.api.moderation_api import PostRestoreDeletedCommentOptions
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    broadcast_id = 'broadcast_id_example' # str |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.post_restore_deleted_comment(tenant_id, comment_id, PostRestoreDeletedCommentOptions(broadcast_id=broadcast_id, sso=sso))
        print("The response of ModerationApi->post_restore_deleted_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->post_restore_deleted_comment: %s\n" % e)

imposta_stato_approvazione_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
commentId	string	path	Sì
approved	boolean	query	No
broadcastId	string	query	No
sso	string	query	No

Risposta

Restituisce: SetCommentApprovedResponse

Esempio

post_set_comment_approval_status Esempio

Copy

import client
from client.api.moderation_api import PostSetCommentApprovalStatusOptions
from client.models.set_comment_approved_response import SetCommentApprovedResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    approved = True # bool |  (opzionale)
    broadcast_id = 'broadcast_id_example' # str |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.post_set_comment_approval_status(tenant_id, comment_id, PostSetCommentApprovalStatusOptions(approved=approved, broadcast_id=broadcast_id, sso=sso))
        print("La risposta di ModerationApi->post_set_comment_approval_status:\n")
        pprint(api_response)
    except Exception as e:
        print("Eccezione durante la chiamata a ModerationApi->post_set_comment_approval_status: %s\n" % e)

imposta_stato_revisione_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
commentId	string	path	Sì
reviewed	boolean	query	No
broadcastId	string	query	No
sso	string	query	No

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio post_set_comment_review_status

Copy

import client
from client.api.moderation_api import PostSetCommentReviewStatusOptions
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per l'elenco di tutti i parametri di configurazione supportati.
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.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str |
    comment_id = 'comment_id_example' # str |
    reviewed = True # bool |  (opzionale)
    broadcast_id = 'broadcast_id_example' # str |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.post_set_comment_review_status(tenant_id, comment_id, PostSetCommentReviewStatusOptions(reviewed=reviewed, broadcast_id=broadcast_id, sso=sso))
        print("The response of ModerationApi->post_set_comment_review_status:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->post_set_comment_review_status: %s\n" % e)

imposta_stato_spam_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
commentId	string	path	Yes
spam	boolean	query	No
permNotSpam	boolean	query	No
broadcastId	string	query	No
sso	string	query	No

Risposta

Restituisce: APIEmptyResponse

Esempio

post_set_comment_spam_status Esempio

Copy

import client
from client.api.moderation_api import PostSetCommentSpamStatusOptions
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    spam = True # bool |  (opzionale)
    perm_not_spam = True # bool |  (opzionale)
    broadcast_id = 'broadcast_id_example' # str |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.post_set_comment_spam_status(tenant_id, comment_id, PostSetCommentSpamStatusOptions(spam=spam, perm_not_spam=perm_not_spam, broadcast_id=broadcast_id, sso=sso))
        print("The response of ModerationApi->post_set_comment_spam_status:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->post_set_comment_spam_status: %s\n" % e)

imposta_testo_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
commentId	string	path	Sì
broadcastId	string	query	No
sso	string	query	No

Risposta

Restituisce: SetCommentTextResponse

Esempio

post_set_comment_text Esempio

Copy

import client
from client.api.moderation_api import PostSetCommentTextOptions
from client.models.set_comment_text_params import SetCommentTextParams
from client.models.set_comment_text_response import SetCommentTextResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    set_comment_text_params = client.SetCommentTextParams() # SetCommentTextParams | 
    broadcast_id = 'broadcast_id_example' # str |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.post_set_comment_text(tenant_id, comment_id, set_comment_text_params, PostSetCommentTextOptions(broadcast_id=broadcast_id, sso=sso))
        print("The response of ModerationApi->post_set_comment_text:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->post_set_comment_text: %s\n" % e)

rimuovi_segnalazione_commento

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
commentId	string	path	Yes
broadcastId	string	query	No
sso	string	query	No

Risposta

Restituisce: APIEmptyResponse

Esempio

post_un_flag_comment Esempio

Copy

import client
from client.api.moderation_api import PostUnFlagCommentOptions
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e predefinito su https://fastcomments.com
# vedere configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    broadcast_id = 'broadcast_id_example' # str |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.post_un_flag_comment(tenant_id, comment_id, PostUnFlagCommentOptions(broadcast_id=broadcast_id, sso=sso))
        print("La risposta di ModerationApi->post_un_flag_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Eccezione durante la chiamata a ModerationApi->post_un_flag_comment: %s\n" % e)

vota_post

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
commentId	string	path	Sì
direction	string	query	No
broadcastId	string	query	No
sso	string	query	No

Risposta

Restituisce: VoteResponse

Esempio

Esempio post_vote

Copy

import client
from client.api.moderation_api import PostVoteOptions
from client.models.vote_response import VoteResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    direction = 'direction_example' # str |  (optional)
    broadcast_id = 'broadcast_id_example' # str |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.post_vote(tenant_id, comment_id, PostVoteOptions(direction=direction, broadcast_id=broadcast_id, sso=sso))
        print("The response of ModerationApi->post_vote:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->post_vote: %s\n" % e)

assegna_badge

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
badgeId	string	query	Sì
userId	string	query	No
commentId	string	query	No
broadcastId	string	query	No
sso	string	query	No

Risposta

Restituisce: AwardUserBadgeResponse

Esempio

Esempio put_award_badge

Copy

import client
from client.api.moderation_api import PutAwardBadgeOptions
from client.models.award_user_badge_response import AwardUserBadgeResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    badge_id = 'badge_id_example' # str | 
    user_id = 'user_id_example' # str |  (opzionale)
    comment_id = 'comment_id_example' # str |  (opzionale)
    broadcast_id = 'broadcast_id_example' # str |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.put_award_badge(tenant_id, badge_id, PutAwardBadgeOptions(user_id=user_id, comment_id=comment_id, broadcast_id=broadcast_id, sso=sso))
        print("The response of ModerationApi->put_award_badge:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->put_award_badge: %s\n" % e)

chiudi_thread

Parameters

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

Response

Returns: APIEmptyResponse

Example

Esempio put_close_thread

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
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.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.put_close_thread(tenant_id, url_id, sso=sso)
        print("The response of ModerationApi->put_close_thread:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->put_close_thread: %s\n" % e)

rimuovi_badge

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
badgeId	string	query	Yes
userId	string	query	No
commentId	string	query	No
broadcastId	string	query	No
sso	string	query	No

Risposta

Restituisce: RemoveUserBadgeResponse

Esempio

put_remove_badge Esempio

Copy

import client
from client.api.moderation_api import PutRemoveBadgeOptions
from client.models.remove_user_badge_response import RemoveUserBadgeResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e di default è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    badge_id = 'badge_id_example' # str | 
    user_id = 'user_id_example' # str |  (facoltativo)
    comment_id = 'comment_id_example' # str |  (facoltativo)
    broadcast_id = 'broadcast_id_example' # str |  (facoltativo)
    sso = 'sso_example' # str |  (facoltativo)
    try:
        api_response = api_instance.put_remove_badge(tenant_id, badge_id, PutRemoveBadgeOptions(user_id=user_id, comment_id=comment_id, broadcast_id=broadcast_id, sso=sso))
        print("The response of ModerationApi->put_remove_badge:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->put_remove_badge: %s\n" % e)

riapri_thread

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
urlId	string	query	Sì
sso	string	query	No

Risposta

Returns: APIEmptyResponse

Esempio

Esempio put_reopen_thread

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.put_reopen_thread(tenant_id, url_id, sso=sso)
        print("The response of ModerationApi->put_reopen_thread:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->put_reopen_thread: %s\n" % e)

imposta_fattore_fiducia

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
userId	string	query	No
trustFactor	string	query	No
sso	string	query	No

Risposta

Restituisce: SetUserTrustFactorResponse

Esempio

set_trust_factor Esempio

Copy

import client
from client.api.moderation_api import SetTrustFactorOptions
from client.models.set_user_trust_factor_response import SetUserTrustFactorResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (opzionale)
    trust_factor = 'trust_factor_example' # str |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.set_trust_factor(tenant_id, SetTrustFactorOptions(user_id=user_id, trust_factor=trust_factor, sso=sso))
        print("The response of ModerationApi->set_trust_factor:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->set_trust_factor: %s\n" % e)

crea_moderatore

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì

Risposta

Restituisce: CreateModeratorResponse

Esempio

Esempio di create_moderator

Copy

import client
from client.models.create_moderator_body import CreateModeratorBody
from client.models.create_moderator_response import CreateModeratorResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è facoltativa e ha valore predefinito https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Gli esempi per ciascun metodo di autenticazione sono forniti qui sotto, usa l'esempio che
# soddisfa il tuo caso d'uso.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta le righe sottostanti per impostare un prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

elimina_moderatore

Parametri

Nome	Tipo	Posizione	Richiesto
tenantId	string	query	Sì
id	string	path	Sì
sendEmail	string	query	No

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di delete_moderator

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare un prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    send_email = 'send_email_example' # str |  (opzionale)
    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)

ottieni_moderatore

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: GetModeratorResponse

Esempio

Esempio get_moderator

Copy

import client
from client.models.get_moderator_response import GetModeratorResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedere configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# 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_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)

ottieni_moderatori

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì
skip	number	query	No

Risposta

Restituisce: GetModeratorsResponse

Esempio

Esempio get_moderators

Copy

import client
from client.models.get_moderators_response import GetModeratorsResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Gli esempi per ciascun metodo di autenticazione sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare il prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 3.4 # float |  (opzionale)
    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)

invia_invito

Parametri

Name	Type	Location	Required
tenantId	string	query	Sì
id	string	path	Sì
fromName	string	query	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di send_invite

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# 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
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per la API key, se necessario
# Enter a context with an instance of the API client
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    # Crea un'istanza della classe 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)

aggiorna_moderatore

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di update_moderator

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.models.update_moderator_body import UpdateModeratorBody
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e per impostazione predefinita è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autenticazione tramite chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

elimina_conteggio_notifiche

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di delete_notification_count

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usa
# l'esempio che soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Apri un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_conteggio_notifiche_cache

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Yes
id	string	path	Yes

Risposta

Restituisce: GetCachedNotificationCountResponse

Esempio

Esempio di get_cached_notification_count

Copy

import client
from client.models.get_cached_notification_count_response import GetCachedNotificationCountResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Rimuovi il commento qui sotto per impostare un prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_conteggio_notifiche

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
userId	string	query	No
urlId	string	query	No
fromCommentId	string	query	No
viewed	boolean	query	No
type	string	query	No

Risposta

Restituisce: GetNotificationCountResponse

Esempio

get_notification_count Esempio

Copy

import client
from client.api.default_api import GetNotificationCountOptions
from client.models.get_notification_count_response import GetNotificationCountResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e di default è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione della chiave API: api_key
# Decommenta quanto segue per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# Entra in un contesto con un'istanza del client API
# Crea un'istanza della classe API
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 | 
    user_id = 'user_id_example' # str |  (opzionale)
    url_id = 'url_id_example' # str |  (opzionale)
    from_comment_id = 'from_comment_id_example' # str |  (opzionale)
    viewed = True # bool |  (opzionale)
    type = 'type_example' # str |  (opzionale)
    try:
        api_response = api_instance.get_notification_count(tenant_id, GetNotificationCountOptions(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)

ottieni_notifiche

Parametri

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

Risposta

Restituisce: GetNotificationsResponse

Esempio

Esempio get_notifications

Copy

import client
from client.api.default_api import GetNotificationsOptions
from client.models.get_notifications_response import GetNotificationsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
# Il client deve configurare i parametri di autenticazione e autorizzazione in conformità con la politica di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (opzionale)
    url_id = 'url_id_example' # str |  (opzionale)
    from_comment_id = 'from_comment_id_example' # str |  (opzionale)
    viewed = True # bool |  (opzionale)
    type = 'type_example' # str |  (opzionale)
    skip = 3.4 # float |  (opzionale)
    try:
        api_response = api_instance.get_notifications(tenant_id, GetNotificationsOptions(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)

aggiorna_notifica

Parametri

Nome	Tipo	Location	Obbligatorio
tenantId	string	query	Sì
id	string	path	Sì
userId	string	query	No

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di update_notification

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.models.update_notification_body import UpdateNotificationBody
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga qui sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (optional)
    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)

crea_reazione_pagina_v1

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Sì
urlId	string	query	Sì
title	string	query	No

Risposta

Restituisce: CreateV1PageReact

Esempio

Esempio di create_v1_page_react

Copy

import client
from client.models.create_v1_page_react import CreateV1PageReact
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è facoltativa e per impostazione predefinita è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    title = 'title_example' # str |  (opzionale)
    try:
        api_response = api_instance.create_v1_page_react(tenant_id, url_id, title=title)
        print("The response of PublicApi->create_v1_page_react:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->create_v1_page_react: %s\n" % e)

crea_reazione_pagina_v2

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Sì
urlId	string	query	Sì
id	string	query	Sì
title	string	query	No

Risposta

Restituisce: CreateV1PageReact

Esempio

Esempio di create_v2_page_react

Copy

import client
from client.models.create_v1_page_react import CreateV1PageReact
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    id = 'id_example' # str | 
    title = 'title_example' # str |  (opzionale)
    try:
        api_response = api_instance.create_v2_page_react(tenant_id, url_id, id, title=title)
        print("The response of PublicApi->create_v2_page_react:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->create_v2_page_react: %s\n" % e)

elimina_reazione_pagina_v1

Parametri

Name	Type	Location	Required	Description
tenantId	string	path	Sì
urlId	string	query	Sì

Risposta

Restituisce: CreateV1PageReact

Esempio

Esempio di delete_v1_page_react

Copy

import client
from client.models.create_v1_page_react import CreateV1PageReact
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    try:
        api_response = api_instance.delete_v1_page_react(tenant_id, url_id)
        print("The response of PublicApi->delete_v1_page_react:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->delete_v1_page_react: %s\n" % e)

elimina_reazione_pagina_v2

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	path	Yes
urlId	string	query	Yes
id	string	query	Yes

Risposta

Restituisce: CreateV1PageReact

Esempio

Esempio di delete_v2_page_react

Copy

import client
from client.models.create_v1_page_react import CreateV1PageReact
from client.rest import ApiException
from pprint import pprint
# Specificare l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Aprire un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.delete_v2_page_react(tenant_id, url_id, id)
        print("The response of PublicApi->delete_v2_page_react:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->delete_v2_page_react: %s\n" % e)

ottieni_like_pagina_v1

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	path	Sì
urlId	string	query	Sì

Risposta

Restituisce: GetV1PageLikes

Esempio

get_v1_page_likes Esempio

Copy

import client
from client.models.get_v1_page_likes import GetV1PageLikes
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    try:
        api_response = api_instance.get_v1_page_likes(tenant_id, url_id)
        print("The response of PublicApi->get_v1_page_likes:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_v1_page_likes: %s\n" % e)

ottieni_utenti_reazione_pagina_v2

Parametri

Name	Type	Location	Required
tenantId	string	path	Sì
urlId	string	query	Sì
id	string	query	Sì

Response

Restituisce: GetV2PageReactUsersResponse

Esempio

Esempio di get_v2_page_react_users

Copy

import client
from client.models.get_v2_page_react_users_response import GetV2PageReactUsersResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.get_v2_page_react_users(tenant_id, url_id, id)
        print("The response of PublicApi->get_v2_page_react_users:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_v2_page_react_users: %s\n" % e)

ottieni_reazioni_pagina_v2

Parametri

Name	Type	Location	Required	Description
tenantId	string	percorso	Sì
urlId	string	query	Sì

Risposta

Restituisce: GetV2PageReacts

Esempio

Esempio get_v2_page_reacts

Copy

import client
from client.models.get_v2_page_reacts import GetV2PageReacts
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e predefinita su https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    try:
        api_response = api_instance.get_v2_page_reacts(tenant_id, url_id)
        print("The response of PublicApi->get_v2_page_reacts:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_v2_page_reacts: %s\n" % e)

aggiungi_pagina

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì

Risposta

Restituisce: AddPageAPIResponse

Esempio

Esempio 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
# Definire l'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Consulta configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autenticazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Rimuovi il commento qui sotto per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

elimina_pagina

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: DeletePageAPIResponse

Esempio

Esempio di delete_page

Copy

import client
from client.models.delete_page_api_response import DeletePageAPIResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_utenti_offline

Past commenters on the page who are NOT currently online. Sorted by displayName.
Use this after exhausting /users/online to render a "Members" section.
Cursor pagination on commenterName: server walks the partial {tenantId, urlId, commenterName} index from afterName forward via $gt, no $skip cost.

Parameters

Name	Type	Location	Required	Description
tenantId	string	path	Yes
urlId	string	query	Yes	Identificatore URL della pagina (pulito dal server).
afterName	string	query	No	Cursore: passa nextAfterName dalla risposta precedente.
afterUserId	string	query	No	Cursore tie-breaker: passa nextAfterUserId dalla risposta precedente. Obbligatorio quando afterName è impostato così i pareggi di nome non eliminano voci.

Response

Returns: PageUsersOfflineResponse

Example

Esempio get_offline_users

Copy

import client
from client.api.public_api import GetOfflineUsersOptions
from client.models.page_users_offline_response import PageUsersOfflineResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e di default è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
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 | Identificatore URL della pagina (pulito dal server).
    after_name = 'after_name_example' # str | Cursore: passa nextAfterName dalla risposta precedente. (opzionale)
    after_user_id = 'after_user_id_example' # str | Cursore tie-breaker: passa nextAfterUserId dalla risposta precedente. Obbligatorio quando afterName è impostato così i pareggi di nome non eliminano voci. (opzionale)
    try:
        api_response = api_instance.get_offline_users(tenant_id, url_id, GetOfflineUsersOptions(after_name=after_name, after_user_id=after_user_id))
        print("The response of PublicApi->get_offline_users:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_offline_users: %s\n" % e)

ottieni_utenti_online

Visualizzatori attualmente online di una pagina: persone la cui sessione websocket è iscritta alla pagina in questo momento.
Restituisce anonCount + totalCount (abbonati a tutta la stanza, inclusi visualizzatori anonimi che non enumeriamo).

Parameters

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	path	Sì
urlId	string	query	Sì	Identificatore URL della pagina (pulito lato server).
afterName	string	query	No	Cursore: passa nextAfterName dalla risposta precedente.
afterUserId	string	query	No	Cursore di sblocco: passa nextAfterUserId dalla risposta precedente. Necessario quando afterName è impostato affinché i pareggi di nome non eliminino le voci.

Response

Restituisce: PageUsersOnlineResponse

Example

Esempio get_online_users

Copy

import client
from client.api.public_api import GetOnlineUsersOptions
from client.models.page_users_online_response import PageUsersOnlineResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | Identificatore URL della pagina (pulito lato server).
    after_name = 'after_name_example' # str | Cursore: passa nextAfterName dalla risposta precedente. (opzionale)
    after_user_id = 'after_user_id_example' # str | Cursore di sblocco: passa nextAfterUserId dalla risposta precedente. Necessario quando afterName è impostato affinché i pareggi di nome non eliminino le voci. (opzionale)
    try:
        api_response = api_instance.get_online_users(tenant_id, url_id, GetOnlineUsersOptions(after_name=after_name, after_user_id=after_user_id))
        print("The response of PublicApi->get_online_users:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_online_users: %s\n" % e)

ottieni_pagina_per_urlid

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
urlId	string	query	Sì

Risposta

Restituisce: GetPageByURLIdAPIResponse

Esempio

get_page_by_urlid Esempio

Copy

import client
from client.models.get_page_by_urlid_api_response import GetPageByURLIdAPIResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti sotto, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_pagine

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì

Risposta

Restituisce: GetPagesAPIResponse

Esempio

Esempio get_pages

Copy

import client
from client.models.get_pages_api_response import GetPagesAPIResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# 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 | 
    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)

ottieni_pagine_pubbliche

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

Parameters

Name	Type	Location	Required	Description
tenantId	string	path	Yes
cursor	string	query	No	Opaque pagination cursor returned as `nextCursor` from a prior request. Tied to the same `sortBy`.
limit	integer	query	No	1..200, default 50
q	string	query	No	Optional case-insensitive title prefix filter.
sortBy	string	query	No	Sort order. `updatedAt` (default, newest first), `commentCount` (most comments first), or `title` (alphabetical).
hasComments	boolean	query	No	If true, only return pages with at least one comment.

Response

Returns: GetPublicPagesResponse

Example

get_pages_public Esempio

Copy

import client
from client.api.public_api import GetPagesPublicOptions
from client.models.get_public_pages_response import GetPublicPagesResponse
from client.models.pages_sort_by import PagesSortBy
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    cursor = 'cursor_example' # str | Opaque pagination cursor returned as `nextCursor` from a prior request. Tied to the same `sortBy`. (optional)
    limit = 56 # int | 1..200, default 50 (optional)
    q = 'q_example' # str | Optional case-insensitive title prefix filter. (optional)
    sort_by = client.PagesSortBy() # PagesSortBy | Sort order. `updatedAt` (default, newest first), `commentCount` (most comments first), or `title` (alphabetical). (optional)
    has_comments = True # bool | If true, only return pages with at least one comment. (optional)
    try:
        api_response = api_instance.get_pages_public(tenant_id, GetPagesPublicOptions(cursor=cursor, limit=limit, q=q, sort_by=sort_by, has_comments=has_comments))
        print("The response of PublicApi->get_pages_public:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_pages_public: %s\n" % e)

ottieni_info_utenti

Informazioni utente in blocco per un tenant. Dati i userIds, restituisce le informazioni di visualizzazione da User / SSOUser. Usato dal widget dei commenti per arricchire gli utenti che sono appena apparsi tramite un evento di presenza. Nessun contesto di pagina: la privacy è applicata in modo uniforme (i profili privati sono mascherati).

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	path	Yes
ids	string	query	Yes	userIds separati da virgola.

Risposta

Restituisce: PageUsersInfoResponse

Esempio

Esempio di get_users_info

Copy

import client
from client.models.page_users_info_response import PageUsersInfoResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    ids = 'ids_example' # str | userIds separati da virgola.
    try:
        api_response = api_instance.get_users_info(tenant_id, ids)
        print("The response of PublicApi->get_users_info:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_users_info: %s\n" % e)

modifica_pagina

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Response

Restituisce: PatchPageAPIResponse

Esempio

Esempio 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
# La definizione dell'host è opzionale e predefinita a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta sotto per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

elimina_evento_webhook_in_sospeso

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di delete_pending_webhook_event

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti qui sotto, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configurare l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta sotto per impostare un prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    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)

ottieni_conteggio_eventi_webhook_in_sospeso

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
commentId	string	query	No
externalId	string	query	No
eventType	string	query	No
type	string	query	No
domain	string	query	No
attemptCountGT	number	query	No

Risposta

Restituisce: GetPendingWebhookEventCountResponse

Esempio

Esempio get_pending_webhook_event_count

Copy

import client
from client.api.default_api import GetPendingWebhookEventCountOptions
from client.models.get_pending_webhook_event_count_response import GetPendingWebhookEventCountResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione via chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (ad esempio Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    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)
    try:
        api_response = api_instance.get_pending_webhook_event_count(tenant_id, GetPendingWebhookEventCountOptions(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)

ottieni_eventi_webhook_in_sospeso

Parameters

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
commentId	string	query	No
externalId	string	query	No
eventType	string	query	No
type	string	query	No
domain	string	query	No
attemptCountGT	number	query	No
skip	number	query	No

Response

Restituisce: GetPendingWebhookEventsResponse

Esempio

Esempio get_pending_webhook_events

Copy

import client
from client.api.default_api import GetPendingWebhookEventsOptions
from client.models.get_pending_webhook_events_response import GetPendingWebhookEventsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e di default è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str |  (opzionale)
    external_id = 'external_id_example' # str |  (opzionale)
    event_type = 'event_type_example' # str |  (opzionale)
    type = 'type_example' # str |  (opzionale)
    domain = 'domain_example' # str |  (opzionale)
    attempt_count_gt = 3.4 # float |  (opzionale)
    skip = 3.4 # float |  (opzionale)
    try:
        api_response = api_instance.get_pending_webhook_events(tenant_id, GetPendingWebhookEventsOptions(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)

crea_configurazione_domanda

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì

Risposta

Restituisce: CreateQuestionConfigResponse

Esempio

Esempio di create_question_config

Copy

import client
from client.models.create_question_config_body import CreateQuestionConfigBody
from client.models.create_question_config_response import CreateQuestionConfigResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e di default è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ciascun metodo di autenticazione sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta sotto per impostare il prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

elimina_configurazione_domanda

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Yes
id	string	path	Yes

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di delete_question_config

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_configurazione_domanda

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: GetQuestionConfigResponse

Esempio

Esempio di get_question_config

Copy

import client
from client.models.get_question_config_response import GetQuestionConfigResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Degli esempi per ogni metodo di autenticazione sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_configurazioni_domanda

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
skip	number	query	No

Risposta

Restituisce: GetQuestionConfigsResponse

Esempio

Esempio di get_question_configs

Copy

import client
from client.models.get_question_configs_response import GetQuestionConfigsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autenticazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 3.4 # float |  (optional)
    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)

aggiorna_configurazione_domanda

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di update_question_config

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.models.update_question_config_body import UpdateQuestionConfigBody
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Sono forniti esempi per ogni metodo di autenticazione qui sotto; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare il prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

crea_risultato_domanda

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì

Risposta

Restituisce: CreateQuestionResultResponse

Esempio

Esempio create_question_result

Copy

import client
from client.models.create_question_result_body import CreateQuestionResultBody
from client.models.create_question_result_response import CreateQuestionResultResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

elimina_risultato_domanda

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di delete_question_result

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga seguente per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_risultato_domanda

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: GetQuestionResultResponse

Esempio

Esempio di get_question_result

Copy

import client
from client.models.get_question_result_response import GetQuestionResultResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usare l'esempio che
# soddisfa il vostro caso d'uso di autenticazione.
# Configurare l'autorizzazione con API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommentare la riga seguente per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe 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)

ottieni_risultati_domanda

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
urlId	string	query	No
userId	string	query	No
startDate	string	query	No
questionId	string	query	No
questionIds	string	query	No
skip	number	query	No

Risposta

Restituisce: GetQuestionResultsResponse

Esempio

Esempio get_question_results

Copy

import client
from client.api.default_api import GetQuestionResultsOptions
from client.models.get_question_results_response import GetQuestionResultsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti sotto, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str |  (opzionale)
    user_id = 'user_id_example' # str |  (opzionale)
    start_date = 'start_date_example' # str |  (opzionale)
    question_id = 'question_id_example' # str |  (opzionale)
    question_ids = 'question_ids_example' # str |  (opzionale)
    skip = 3.4 # float |  (opzionale)
    try:
        api_response = api_instance.get_question_results(tenant_id, GetQuestionResultsOptions(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)

aggiorna_risultato_domanda

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di update_question_result

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.models.update_question_result_body import UpdateQuestionResultBody
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta quanto sotto per impostare il prefisso (e.g. Bearer) per api_key, se necessario
# 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_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)

aggregare_risultati_domanda

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
questionId	string	query	No
questionIds	array	query	No
urlId	string	query	No
timeBucket	string	query	No
startDate	string	query	No
forceRecalculate	boolean	query	No

Response

Returns: AggregateQuestionResultsResponse

Esempio

aggregate_question_results Esempio

Copy

import client
from client.api.default_api import AggregateQuestionResultsOptions
from client.models.aggregate_question_results_response import AggregateQuestionResultsResponse
from client.models.aggregate_time_bucket import AggregateTimeBucket
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Sono forniti esempi per ogni metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    question_id = 'question_id_example' # str |  (opzionale)
    question_ids = ['question_ids_example'] # List[str] |  (opzionale)
    url_id = 'url_id_example' # str |  (opzionale)
    time_bucket = client.AggregateTimeBucket() # AggregateTimeBucket |  (opzionale)
    start_date = '2013-10-20T19:20:30+01:00' # datetime |  (opzionale)
    force_recalculate = True # bool |  (opzionale)
    try:
        api_response = api_instance.aggregate_question_results(tenant_id, AggregateQuestionResultsOptions(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)

aggregare_risultati_domanda_bulk

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
forceRecalculate	boolean	query	No

Risposta

Restituisce: BulkAggregateQuestionResultsResponse

Esempio

Esempio di bulk_aggregate_question_results

Copy

import client
from client.models.bulk_aggregate_question_results_request import BulkAggregateQuestionResultsRequest
from client.models.bulk_aggregate_question_results_response import BulkAggregateQuestionResultsResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e predefinita a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di auth; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare un prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (opzionale)
    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)

combina_commenti_con_risultati_domanda

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
questionId	string	query	No
questionIds	array	query	No
urlId	string	query	No
startDate	string	query	No
forceRecalculate	boolean	query	No
minValue	number	query	No
maxValue	number	query	No
limit	number	query	No

Risposta

Restituisce: CombineQuestionResultsWithCommentsResponse

Esempio

combine_comments_with_question_results Esempio

Copy

import client
from client.api.default_api import CombineCommentsWithQuestionResultsOptions
from client.models.combine_question_results_with_comments_response import CombineQuestionResultsWithCommentsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e di default è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
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 | 
    question_id = 'question_id_example' # str |  (optional)
    question_ids = ['question_ids_example'] # List[str] |  (optional)
    url_id = 'url_id_example' # str |  (optional)
    start_date = '2013-10-20T19:20:30+01:00' # datetime |  (optional)
    force_recalculate = True # bool |  (optional)
    min_value = 3.4 # float |  (optional)
    max_value = 3.4 # float |  (optional)
    limit = 3.4 # float |  (optional)
    try:
        api_response = api_instance.combine_comments_with_question_results(tenant_id, CombineCommentsWithQuestionResultsOptions(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)

aggiungi_utente_sso

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì

Risposta

Restituisce: AddSSOUserAPIResponse

Esempio

Esempio di 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
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ogni metodo di auth sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare un prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

elimina_utente_sso

Parameters

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
id	string	path	Yes
deleteComments	boolean	query	No
commentDeleteMode	string	query	No

Response

Restituisce: DeleteSSOUserAPIResponse

Esempio

delete_sso_user Esempio

Copy

import client
from client.api.default_api import DeleteSsoUserOptions
from client.models.delete_sso_user_api_response import DeleteSSOUserAPIResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
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 | 
    delete_comments = True # bool |  (optional)
    comment_delete_mode = 'comment_delete_mode_example' # str |  (optional)
    try:
        api_response = api_instance.delete_sso_user(tenant_id, id, DeleteSsoUserOptions(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)

ottieni_utente_sso_per_email

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì
email	string	path	Sì

Risposta

Restituisce: GetSSOUserByEmailAPIResponse

Esempio

Esempio di 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
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti qui sotto, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta quanto segue per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_utente_sso_per_id

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: GetSSOUserByIdAPIResponse

Esempio

Esempio di 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
# La definizione dell'host è opzionale e di default è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_utenti_sso

Parametri

Nome	Tipo	Posizione	Richiesto	Descrizione
tenantId	string	query	Sì
skip	integer	query	No

Risposta

Restituisce: GetSSOUsersResponse

Esempio

Esempio di get_sso_users

Copy

import client
from client.models.get_sso_users_response import GetSSOUsersResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e per default è https://fastcomments.com
# Consulta configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare un prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 56 # int |  (opzionale)
    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)

modifica_utente_sso

Parametri

Nome	Tipo	Location	Obbligatorio
tenantId	string	query	Sì
id	string	path	Sì
updateComments	boolean	query	No

Risposta

Restituisce: PatchSSOUserAPIResponse

Esempio

Esempio di 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
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Rimuovi il commento qui sotto per impostare un prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (opzionale)
    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)

imposta_utente_sso

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
id	string	path	Sì
updateComments	boolean	query	No

Risposta

Restituisce: PutSSOUserAPIResponse

Esempio

Esempio put_sso_user

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
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione; usa l'esempio che
# soddisfa il tuo caso d'uso.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Rimuovi il commento sottostante per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (opzionale)
    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)

crea_sottoscrizione

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì

Risposta

Restituisce: CreateSubscriptionAPIResponse

Esempio

Esempio di 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
# Definire l'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

elimina_sottoscrizione

Parametri

Name	Type	Location	Required
tenantId	string	query	Yes
id	string	path	Yes
userId	string	query	No

Risposta

Restituisce: DeleteSubscriptionAPIResponse

Esempio

Esempio di delete_subscription

Copy

import client
from client.models.delete_subscription_api_response import DeleteSubscriptionAPIResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e per impostazione predefinita è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Rimuovi il commento qui sotto per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    user_id = 'user_id_example' # str |  (optional)
    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)

ottieni_sottoscrizioni

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
userId	string	query	No

Risposta

Restituisce: GetSubscriptionsAPIResponse

Esempio

Esempio di get_subscriptions

Copy

import client
from client.models.get_subscriptions_api_response import GetSubscriptionsAPIResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (opzionale)
    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)

aggiorna_sottoscrizione

Parametri

Name	Type	Location	Required
tenantId	string	query	Sì
id	string	path	Sì
userId	string	query	No

Risposta

Restituisce: UpdateSubscriptionAPIResponse

Esempio

Esempio di 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
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Consultare configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usare l'esempio che
# soddisfa il vostro caso d'uso.
# Configurare l'autenticazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommentare qui sotto per impostare un prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe 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 |  (opzionale)
    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)

ottieni_utilizzi_giornalieri_tenant

Parametri

Name	Type	Location	Required
tenantId	string	query	Yes
yearNumber	number	query	No
monthNumber	number	query	No
dayNumber	number	query	No
skip	number	query	No

Risposta

Restituisce: GetTenantDailyUsagesResponse

Esempio

Esempio get_tenant_daily_usages

Copy

import client
from client.api.default_api import GetTenantDailyUsagesOptions
from client.models.get_tenant_daily_usages_response import GetTenantDailyUsagesResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito su https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    year_number = 3.4 # float |  (optional)
    month_number = 3.4 # float |  (optional)
    day_number = 3.4 # float |  (optional)
    skip = 3.4 # float |  (optional)
    try:
        api_response = api_instance.get_tenant_daily_usages(tenant_id, GetTenantDailyUsagesOptions(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)

crea_pacchetto_tenant

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì

Risposta

Restituisce: CreateTenantPackageResponse

Esempio

Esempio di create_tenant_package

Copy

import client
from client.models.create_tenant_package_body import CreateTenantPackageBody
from client.models.create_tenant_package_response import CreateTenantPackageResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e predefinita a https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti qui sotto; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga qui sotto per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

elimina_pacchetto_tenant

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

delete_tenant_package Esempio

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Consultare configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Vengono forniti esempi per ogni metodo di autenticazione qui sotto; usare l'esempio che
# soddisfa il proprio caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommentare la riga sottostante per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe 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)

ottieni_pacchetto_tenant

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: GetTenantPackageResponse

Esempio

Esempio di get_tenant_package

Copy

import client
from client.models.get_tenant_package_response import GetTenantPackageResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e utilizza https://fastcomments.com per impostazione predefinita
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Rimuovi il commento qui sotto per impostare il prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_pacchetti_tenant

Parametri

Nome	Tipo	Posizione	Richiesto	Descrizione
tenantId	string	query	Sì
skip	number	query	No

Risposta

Restituisce: GetTenantPackagesResponse

Esempio

Esempio di get_tenant_packages

Copy

import client
from client.models.get_tenant_packages_response import GetTenantPackagesResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta sotto per impostare il prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 3.4 # float |  (opzionale)
    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)

sostituisci_pacchetto_tenant

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Yes
id	string	path	Yes

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di replace_tenant_package

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.models.replace_tenant_package_body import ReplaceTenantPackageBody
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e per default è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usare l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configurare l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommentare sotto per impostare il prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe 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)

aggiorna_pacchetto_tenant

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di update_tenant_package

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.models.update_tenant_package_body import UpdateTenantPackageBody
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e usa https://fastcomments.com come valore predefinito
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Rimuovi il commento qui sotto per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    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)

crea_utente_tenant

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì

Risposta

Restituisce: CreateTenantUserResponse

Esempio

Esempio di create_tenant_user

Copy

import client
from client.models.create_tenant_user_body import CreateTenantUserBody
from client.models.create_tenant_user_response import CreateTenantUserResponse
from client.rest import ApiException
from pprint import pprint
# L'impostazione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ciascun metodo di autenticazione; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare un prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

elimina_utente_tenant

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
id	string	path	Yes
deleteComments	string	query	No
commentDeleteMode	string	query	No

Risposta

Returns: APIEmptyResponse

Esempio

Esempio delete_tenant_user

Copy

import client
from client.api.default_api import DeleteTenantUserOptions
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usare l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (ad es. Bearer) per la chiave API, se necessario
# 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 | 
    delete_comments = 'delete_comments_example' # str |  (optional)
    comment_delete_mode = 'comment_delete_mode_example' # str |  (optional)
    try:
        api_response = api_instance.delete_tenant_user(tenant_id, id, DeleteTenantUserOptions(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)

ottieni_utente_tenant

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: GetTenantUserResponse

Esempio

Esempio di get_tenant_user

Copy

import client
from client.models.get_tenant_user_response import GetTenantUserResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configurare l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare un prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_utenti_tenant

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì
skip	number	query	No

Risposta

Restituisce: GetTenantUsersResponse

Esempio

Esempio di get_tenant_users

Copy

import client
from client.models.get_tenant_users_response import GetTenantUsersResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è 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.
# Configura l'autenticazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare un prefisso (e.g. Bearer) per API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Apri un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 3.4 # float |  (opzionale)
    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)

sostituisci_utente_tenant

Parametri

Name	Type	Location	Required
tenantId	string	query	Sì
id	string	path	Sì
updateComments	string	query	No

Risposta

Returns: APIEmptyResponse

Esempio

Esempio di replace_tenant_user

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.models.replace_tenant_user_body import ReplaceTenantUserBody
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e per default è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ciascun metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# 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 | 
    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)

Parametri

Name	Type	Location	Required
tenantId	string	query	Sì
id	string	path	Sì
redirectURL	string	query	No

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di send_login_link

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ciascun metodo di auth sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    redirect_url = 'redirect_url_example' # str |  (opzionale)
    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)

aggiorna_utente_tenant

Parametri

Name	Type	Location	Obbligatorio
tenantId	string	query	Sì
id	string	path	Sì
updateComments	string	query	No

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio di update_tenant_user

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.models.update_tenant_user_body import UpdateTenantUserBody
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è facoltativa e predefinita a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Gli esempi per ciascun metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare un prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (opzionale)
    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)

crea_tenant

Parametri

Nome	Tipo	Posizione	Richiesto	Descrizione
tenantId	string	query	Sì

Risposta

Restituisce: CreateTenantResponse

Esempio

Esempio di create_tenant

Copy

import client
from client.models.create_tenant_body import CreateTenantBody
from client.models.create_tenant_response import CreateTenantResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta quanto sotto per impostare un prefisso (es. Bearer) per API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

elimina_tenant

Parametri

Name	Type	Location	Required
tenantId	string	query	Sì
id	string	path	Sì
sure	string	query	No

Response

Restituisce: APIEmptyResponse

Esempio

Esempio di delete_tenant

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Consulta configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per api_key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    sure = 'sure_example' # str |  (optional)
    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)

ottieni_tenant

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: GetTenantResponse

Esempio

Esempio di get_tenant

Copy

import client
from client.models.get_tenant_response import GetTenantResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Consulta configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Di seguito sono forniti esempi per ciascun metodo di autenticazione; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga seguente per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_tenant

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
meta	string	query	No
skip	number	query	No

Risposta

Restituisce: GetTenantsResponse

Esempio

Esempio get_tenants

Copy

import client
from client.api.default_api import GetTenantsOptions
from client.models.get_tenants_response import GetTenantsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
# Il client deve configurare i parametri di autenticazione e autorizzazione in conformità con la policy di sicurezza del server API.
# Esempi per ciascun metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione della chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta quanto segue per impostare il prefisso (ad esempio Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    meta = 'meta_example' # str |  (opzionale)
    skip = 3.4 # float |  (opzionale)
    try:
        api_response = api_instance.get_tenants(tenant_id, GetTenantsOptions(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)

aggiorna_tenant

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Yes
id	string	path	Yes

Risposta

Restituisce: APIEmptyResponse

Esempio

Esempio update_tenant

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.models.update_tenant_body import UpdateTenantBody
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione; usa
# l'esempio che soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autenticazione tramite chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare un prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

cambia_stato_ticket

Parametri

Name	Type	Location	Required
tenantId	string	query	Sì
userId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: ChangeTicketStateResponse

Esempio

Esempio di change_ticket_state

Copy

import client
from client.models.change_ticket_state_body import ChangeTicketStateBody
from client.models.change_ticket_state_response import ChangeTicketStateResponse
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.
# 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 | 
    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)

crea_ticket

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
userId	string	query	Sì

Risposta

Restituisce: CreateTicketResponse

Esempio

Esempio di create_ticket

Copy

import client
from client.models.create_ticket_body import CreateTicketBody
from client.models.create_ticket_response import CreateTicketResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e per default è https://fastcomments.com
# Vedere configuration.py per la lista di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Sono forniti esempi per ogni metodo di autenticazione di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommentare sotto per impostare il prefisso (e.g. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe 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)

ottieni_ticket

Parametri

Nome	Tipo	Posizione	Richiesto
tenantId	string	query	Sì
id	string	path	Sì
userId	string	query	No

Risposta

Restituisce: GetTicketResponse

Esempio

Esempio di get_ticket

Copy

import client
from client.models.get_ticket_response import GetTicketResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è facoltativa e predefinita a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione; usa l'esempio
# che soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga seguente per impostare un prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    user_id = 'user_id_example' # str |  (optional)
    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)

ottieni_ticket

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
userId	string	query	No
state	number	query	No
skip	number	query	No
limit	number	query	No

Risposta

Restituisce: GetTicketsResponse

Esempio

Esempio get_tickets

Copy

import client
from client.api.default_api import GetTicketsOptions
from client.models.get_tickets_response import GetTicketsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta sotto per impostare il prefisso (ad es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (optional)
    state = 3.4 # float |  (optional)
    skip = 3.4 # float |  (optional)
    limit = 3.4 # float |  (optional)
    try:
        api_response = api_instance.get_tickets(tenant_id, GetTicketsOptions(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)

ottieni_traduzioni

Parametri

Nome	Tipo	Posizione	Obbligatorio
namespace	string	path	Sì
component	string	path	Sì
locale	string	query	No
useFullTranslationIds	boolean	query	No

Risposta

Restituisce: GetTranslationsResponse

Esempio

Esempio get_translations

Copy

import client
from client.api.public_api import GetTranslationsOptions
from client.models.get_translations_response import GetTranslationsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    namespace = 'namespace_example' # str | 
    component = 'component_example' # str | 
    locale = 'locale_example' # str |  (optional)
    use_full_translation_ids = True # bool |  (optional)
    try:
        api_response = api_instance.get_translations(namespace, component, GetTranslationsOptions(locale=locale, use_full_translation_ids=use_full_translation_ids))
        print("The response of PublicApi->get_translations:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_translations: %s\n" % e)

carica_immagine

Carica e ridimensiona un'immagine

Parametri

Name	Type	Location	Required	Description
tenantId	string	path	Yes
sizePreset	string	query	No	Preset di dimensione: "Default" (1000x1000px) o "CrossPlatform" (crea dimensioni per i dispositivi più diffusi)
urlId	string	query	No	ID della pagina da cui avviene il caricamento, da configurare

Risposta

Restituisce: UploadImageResponse

Esempio

upload_image Esempio

Copy

import client
from client.api.public_api import UploadImageOptions
from client.models.size_preset import SizePreset
from client.models.upload_image_response import UploadImageResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
# Creare un'istanza della classe API
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 | 
    file = None # bytes | 
    size_preset = client.SizePreset() # SizePreset | Preset di dimensione: \"Default\" (1000x1000px) o \"CrossPlatform\" (crea dimensioni per i dispositivi più diffusi) (opzionale)
    url_id = 'url_id_example' # str | ID della pagina da cui avviene il caricamento, da configurare (opzionale)
    try:
        api_response = api_instance.upload_image(tenant_id, file, UploadImageOptions(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)

ottieni_progresso_badge_utente_per_id

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: APIGetUserBadgeProgressResponse

Esempio

Esempio di get_user_badge_progress_by_id

Copy

import client
from client.models.api_get_user_badge_progress_response import APIGetUserBadgeProgressResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e predefinita a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# 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'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_progresso_badge_utente_per_user_id

Parametri

Name	Tipo	Posizione	Richiesto	Descrizione
tenantId	string	query	Sì
userId	string	path	Sì

Risposta

Restituisce: APIGetUserBadgeProgressResponse

Esempio

Esempio di get_user_badge_progress_by_user_id

Copy

import client
from client.models.api_get_user_badge_progress_response import APIGetUserBadgeProgressResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di auth; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga seguente per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_lista_progresso_badge_utente

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
userId	string	query	No
limit	number	query	No
skip	number	query	No

Risposta

Restituisce: APIGetUserBadgeProgressListResponse

Esempio

Esempio get_user_badge_progress_list

Copy

import client
from client.api.default_api import GetUserBadgeProgressListOptions
from client.models.api_get_user_badge_progress_list_response import APIGetUserBadgeProgressListResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ciascun metodo di autenticazione sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (optional)
    limit = 3.4 # float |  (optional)
    skip = 3.4 # float |  (optional)
    try:
        api_response = api_instance.get_user_badge_progress_list(tenant_id, GetUserBadgeProgressListOptions(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)

crea_badge_utente

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì

Risposta

Restituisce: APICreateUserBadgeResponse

Esempio

Esempio di create_user_badge

Copy

import client
from client.models.api_create_user_badge_response import APICreateUserBadgeResponse
from client.models.create_user_badge_params import CreateUserBadgeParams
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

elimina_badge_utente

Parametri

Nome	Tipo	Location	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: APIEmptySuccessResponse

Esempio

Esempio di delete_user_badge

Copy

import client
from client.models.api_empty_success_response import APIEmptySuccessResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e usa per default https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_badge_utente

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: APIGetUserBadgeResponse

Esempio

Esempio di get_user_badge

Copy

import client
from client.models.api_get_user_badge_response import APIGetUserBadgeResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Di seguito sono forniti esempi per ogni metodo di autenticazione; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta quanto sotto per impostare un prefisso (es. Bearer) per l'API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_badge_utente

Parametri

Name	Type	Location	Required
tenantId	string	query	Yes
userId	string	query	No
badgeId	string	query	No
type	number	query	No
displayedOnComments	boolean	query	No
limit	number	query	No
skip	number	query	No

Risposta

Restituisce: APIGetUserBadgesResponse

Esempio

Esempio get_user_badges

Copy

import client
from client.api.default_api import GetUserBadgesOptions
from client.models.api_get_user_badges_response import APIGetUserBadgesResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ciascun metodo di autenticazione sono forniti sotto, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione della chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (optional)
    badge_id = 'badge_id_example' # str |  (optional)
    type = 3.4 # float |  (optional)
    displayed_on_comments = True # bool |  (optional)
    limit = 3.4 # float |  (optional)
    skip = 3.4 # float |  (optional)
    try:
        api_response = api_instance.get_user_badges(tenant_id, GetUserBadgesOptions(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)

aggiorna_badge_utente

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: APIEmptySuccessResponse

Esempio

Esempio di update_user_badge

Copy

import client
from client.models.api_empty_success_response import APIEmptySuccessResponse
from client.models.update_user_badge_params import UpdateUserBadgeParams
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con le policy di sicurezza del server API.
# Gli esempi per ogni metodo di autenticazione sono forniti sotto; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga seguente per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_conteggio_notifiche_utente

Parametri

Nome	Tipo	Posizione	Richiesto	Descrizione
tenantId	string	query	Sì
sso	string	query	No

Risposta

Restituisce: GetUserNotificationCountResponse

Esempio

Esempio get_user_notification_count

Copy

import client
from client.models.get_user_notification_count_response import GetUserNotificationCountResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è facoltativa e per impostazione predefinita è https://fastcomments.com
# Consultare configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    sso = 'sso_example' # str |  (optional)
    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)

ottieni_notifiche_utente

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
urlId	string	query	No	Utilizzato per determinare se la pagina corrente è sottoscritta.
pageSize	integer	query	No
afterId	string	query	No
includeContext	boolean	query	No
afterCreatedAt	integer	query	No
unreadOnly	boolean	query	No
dmOnly	boolean	query	No
noDm	boolean	query	No
includeTranslations	boolean	query	No
includeTenantNotifications	boolean	query	No
sso	string	query	No

Risposta

Restituisce: GetMyNotificationsResponse

Esempio

Esempio get_user_notifications

Copy

import client
from client.api.public_api import GetUserNotificationsOptions
from client.models.get_my_notifications_response import GetMyNotificationsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
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 | Utilizzato per determinare se la pagina corrente è sottoscritta. (opzionale)
    page_size = 56 # int |  (opzionale)
    after_id = 'after_id_example' # str |  (opzionale)
    include_context = True # bool |  (opzionale)
    after_created_at = 56 # int |  (opzionale)
    unread_only = True # bool |  (opzionale)
    dm_only = True # bool |  (opzionale)
    no_dm = True # bool |  (opzionale)
    include_translations = True # bool |  (opzionale)
    include_tenant_notifications = True # bool |  (opzionale)
    sso = 'sso_example' # str |  (opzionale)
    try:
        api_response = api_instance.get_user_notifications(tenant_id, GetUserNotificationsOptions(url_id=url_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, include_tenant_notifications=include_tenant_notifications, 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)

resetta_conteggio_notifiche_utente

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Sì
sso	string	query	No

Risposta

Restituisce: ResetUserNotificationsResponse

Esempio

Esempio di reset_user_notification_count

Copy

import client
from client.models.reset_user_notifications_response import ResetUserNotificationsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    sso = 'sso_example' # str |  (opzionale)
    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)

resetta_notifiche_utente

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
afterId	string	query	No
afterCreatedAt	integer	query	No
unreadOnly	boolean	query	No
dmOnly	boolean	query	No
noDm	boolean	query	No
sso	string	query	No

Risposta

Restituisce: ResetUserNotificationsResponse

Esempio

reset_user_notifications Esempio

Copy

import client
from client.api.public_api import ResetUserNotificationsOptions
from client.models.reset_user_notifications_response import ResetUserNotificationsResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    after_id = 'after_id_example' # str |  (optional)
    after_created_at = 56 # int |  (optional)
    unread_only = True # bool |  (optional)
    dm_only = True # bool |  (optional)
    no_dm = True # bool |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.reset_user_notifications(tenant_id, ResetUserNotificationsOptions(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)

aggiorna_stato_sottoscrizione_notifica_commento_utente

Abilita o disabilita le notifiche per un commento specifico.

Parametri

Name	Type	Location	Required
tenantId	string	query	Yes
notificationId	string	path	Yes
optedInOrOut	string	path	Yes
commentId	string	query	Yes
sso	string	query	No

Risposta

Restituisce: UpdateUserNotificationCommentSubscriptionStatusResponse

Esempio

update_user_notification_comment_subscription_status Esempio

Copy

import client
from client.models.update_user_notification_comment_subscription_status_response import UpdateUserNotificationCommentSubscriptionStatusResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (opzionale)
    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)

aggiorna_stato_sottoscrizione_notifica_pagina_utente

Abilita o disabilita le notifiche per una pagina. Quando gli utenti sono iscritti a una pagina, vengono create notifiche per nuovi commenti root, e anche

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Sì
urlId	string	query	Sì
url	string	query	Sì
pageTitle	string	query	Sì
subscribedOrUnsubscribed	string	path	Sì
sso	string	query	No

Risposta

Restituisce: UpdateUserNotificationPageSubscriptionStatusResponse

Esempio

update_user_notification_page_subscription_status Esempio

Copy

import client
from client.models.update_user_notification_page_subscription_status_response import UpdateUserNotificationPageSubscriptionStatusResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e, per impostazione predefinita, è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Apri un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (opzionale)
    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)

aggiorna_stato_notifica_utente

Parametri

Name	Type	Location	Required
tenantId	string	query	Sì
notificationId	string	path	Sì
newStatus	string	path	Sì
sso	string	query	No

Risposta

Restituisce: UpdateUserNotificationStatusResponse

Esempio

update_user_notification_status Esempio

Copy

import client
from client.models.update_user_notification_status_response import UpdateUserNotificationStatusResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Consulta configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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 |  (optional)
    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)

ottieni_stati_presenza_utente

Parametri

Name	Type	Location	Required
tenantId	string	query	Sì
urlIdWS	string	query	Sì
userIds	string	query	Sì

Risposta

Restituisce: GetUserPresenceStatusesResponse

Esempio

Esempio di get_user_presence_statuses

Copy

import client
from client.models.get_user_presence_statuses_response import GetUserPresenceStatusesResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

cerca_utenti

Parametri

Name	Type	Location	Required
tenantId	string	path	Yes
urlId	string	query	Yes
usernameStartsWith	string	query	No
mentionGroupIds	array	query	No
sso	string	query	No
searchSection	string	query	No

Risposta

Restituisce: SearchUsersResult

Esempio

Esempio search_users

Copy

import client
from client.api.public_api import SearchUsersOptions
from client.models.search_users_result import SearchUsersResult
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrare in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Creare un'istanza della classe 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 |  (optional)
    mention_group_ids = ['mention_group_ids_example'] # List[str] |  (optional)
    sso = 'sso_example' # str |  (optional)
    search_section = 'search_section_example' # str |  (optional)
    try:
        api_response = api_instance.search_users(tenant_id, url_id, SearchUsersOptions(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)

ottieni_utente

Parametri

Name	Type	Location	Obbligatorio	Descrizione
tenantId	string	query	Sì
id	string	path	Sì

Risposta

Restituisce: GetUserResponse

Esempio

Esempio di get_user

Copy

import client
from client.models.get_user_response import GetUserResponse
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.
# 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 | 
    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)

crea_voto

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
commentId	string	query	Yes
direction	string	query	Yes
userId	string	query	No
anonUserId	string	query	No

Response

Restituisce: VoteResponse

Example

Esempio create_vote

Copy

import client
from client.api.default_api import CreateVoteOptions
from client.models.vote_response import VoteResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ciascun metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con chiave API: api_key
# Decommenta la riga seguente per impostare un prefisso (ad es. Bearer) per la chiave API, se necessario
# Entra in un contesto con un'istanza del client API
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:
    # Crea un'istanza della classe API
    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 |  (opzionale)
    anon_user_id = 'anon_user_id_example' # str |  (opzionale)
    try:
        api_response = api_instance.create_vote(tenant_id, comment_id, direction, CreateVoteOptions(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)

elimina_voto

Parametri

Nome	Tipo	Posizione	Richiesto
tenantId	string	query	Yes
id	string	path	Yes
editKey	string	query	No

Risposta

Restituisce: VoteDeleteResponse

Esempio

Esempio delete_vote

Copy

import client
from client.models.vote_delete_response import VoteDeleteResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è opzionale e per impostazione predefinita è https://fastcomments.com
# Consulta configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Gli esempi per ciascun metodo di autenticazione sono forniti qui sotto; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione tramite API key: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta la riga sottostante per impostare un prefisso (es. Bearer) per la API key, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    edit_key = 'edit_key_example' # str |  (opzionale)
    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)

ottieni_voti

Parametri

Nome	Tipo	Posizione	Obbligatorio	Descrizione
tenantId	string	query	Sì
urlId	string	query	Sì

Risposta

Restituisce: GetVotesResponse

Esempio

Esempio get_votes

Copy

import client
from client.models.get_votes_response import GetVotesResponse
from client.rest import ApiException
from pprint import pprint
# La definizione dell'host è opzionale e il valore predefinito è https://fastcomments.com
# Vedi configuration.py per l'elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la politica di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito; usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione con chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta quanto segue per impostare un prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
with client.ApiClient(configuration) as api_client:
    # Crea un'istanza della classe 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)

ottieni_voti_per_utente

Parametri

Nome	Tipo	Posizione	Obbligatorio
tenantId	string	query	Yes
urlId	string	query	Yes
userId	string	query	No
anonUserId	string	query	No

Risposta

Returns: GetVotesForUserResponse

Esempio

Esempio get_votes_for_user

Copy

import client
from client.api.default_api import GetVotesForUserOptions
from client.models.get_votes_for_user_response import GetVotesForUserResponse
from client.rest import ApiException
from pprint import pprint
# Definire l'host è facoltativo e predefinito a https://fastcomments.com
# Vedere configuration.py per un elenco di tutti i parametri di configurazione supportati.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Il client deve configurare i parametri di autenticazione e autorizzazione
# in conformità con la policy di sicurezza del server API.
# Esempi per ogni metodo di autenticazione sono forniti di seguito, usa l'esempio che
# soddisfa il tuo caso d'uso di autenticazione.
# Configura l'autorizzazione della chiave API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Decommenta qui sotto per impostare il prefisso (es. Bearer) per la chiave API, se necessario
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entra in un contesto con un'istanza del client API
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 | 
    url_id = 'url_id_example' # str | 
    user_id = 'user_id_example' # str |  (optional)
    anon_user_id = 'anon_user_id_example' # str |  (optional)
    try:
        api_response = api_instance.get_votes_for_user(tenant_id, url_id, GetVotesForUserOptions(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)

Hai bisogno di aiuto?

Se riscontri problemi o hai domande sul SDK Python, per favore:

Contribuire

I contributi sono benvenuti! Visita il repository GitHub per le linee guida sui contributi.

Lingua 🇮🇹 Italiano

Documentazione

Inizio

Aggregazione

Log di audit

Autenticazione

Blocco dal commento

Controllo commenti bloccati

Commenti

Commenti per utente

Configurazioni dominio

Modelli email

Registro eventi

Post del feed

Segnala commento

GIF

Tag hash

Moderazione

Moderatori

Conteggio notifiche

Notifiche

Reazioni pagina

Pagine

Eventi webhook in sospeso

Configurazioni domanda

Risultati domanda

Aggregazione risultati domanda

Utenti SSO

Sottoscrizioni

Utilizzo giornaliero tenant

Pacchetti tenant

Utenti tenant

Tenant

Ticket

Traduzioni

Caricamento immagine

Progresso badge utente

Badge utente

Notifiche utente

Stato presenza utente

Ricerca utenti

Utenti

Voti

SDK Python FastComments

Repository

Agenti di codifica IA

Installazione

Installa da GitHub

Contenuto della Libreria

API Pubbliche vs Sicure

Avvio rapido

Using Authenticated APIs (DefaultApi)

Using Public APIs (PublicApi)

Using the Moderation Dashboard (ModerationApi)

Using SSO (Single Sign-On)

Live Subscriptions (PubSub)

Common Issues

Note

ID di Broadcast

Requisiti

aggregare

Parameters

Response

Example

ottieni_log_audit

Parametri

Risposta

Esempio

logout_pubblico

Risposta

Esempio

blocca_da_commento_pubblico

Parametri

Risposta

Esempio

sblocca_commento_pubblico

Parametri

Risposta

Esempio

commenti_controllati_per_bloccati