SDK Python de FastComments

Ceci est le SDK Python officiel pour FastComments.

SDK Python officiel pour l'API FastComments

Dépôt

Installation

Installer depuis GitHub

Installez directement à partir d’une balise de version (recommandé, entièrement reproductible) :

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

Épinglez la balise plutôt qu’une branche afin que les builds soient déterministes. La même forme fonctionne dans requirements.txt :

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

Chaque GitHub Release balisée possède également une roue pré‑construite jointe si vous préférez installer un artefact binaire directement.

Contenu de la bibliothèque

Cette bibliothèque contient deux modules : le client API généré et la bibliothèque centrale Python qui comprend des utilitaires écrits à la main pour faciliter l’utilisation de l’API, y compris la prise en charge du SSO.

API publiques vs sécurisées

Pour le client API, il existe trois classes, DefaultApi, PublicApi et ModerationApi. La classe DefaultApi contient des méthodes qui requièrent votre clé API, et PublicApi contient des méthodes pouvant être appelées directement depuis un navigateur, un appareil mobile, etc., sans authentification. La classe ModerationApi fournit une suite étendue d’API de modération en direct et rapides. Chaque méthode ModerationApi accepte un paramètre sso et peut s’authentifier via SSO ou un cookie de session FastComments.com.

Démarrage rapide

Utilisation des API authentifiées (DefaultApi)

Important : Vous devez définir votre clé API dans la Configuration avant d'effectuer des requêtes authentifiées. Sinon, les requêtes échoueront avec une erreur 401.

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

# Create and configure the API client
config = Configuration()
config.host = "https://fastcomments.com"

# REQUIRED: Set your API key (get this from your FastComments dashboard)
config.api_key = {"api_key": "YOUR_API_KEY_HERE"}

# Create the API instance with the configured client
api_client = ApiClient(configuration=config)
api = DefaultApi(api_client)

# Now you can make authenticated API calls
try:
    # Example: Add an SSO user
    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}")
    # Common errors:
    # - 401: API key is missing or invalid
    # - 400: Request validation failed

Utilisation des API publiques (PublicApi)

Les points de terminaison publics ne nécessitent pas d'authentification :

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}")

Utilisation du tableau de bord de modération (ModerationApi)

Le ModerationApi alimente le tableau de bord des modérateurs. Les méthodes sont appelées au nom d'un modérateur en transmettant un jeton sso :

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:
    # Count the comments awaiting moderation
    response = moderation_api.get_count(GetCountOptions(sso="SSO_TOKEN"))
    print(response)
except Exception as e:
    print(f"Error: {e}")

Utilisation du SSO (Single Sign-On)

Le SDK comprend des utilitaires pour générer des jetons SSO sécurisés :

from sso import FastCommentsSSO, SecureSSOUserData

# Create user data (id, email, and username are required)
user_data = SecureSSOUserData(
    id="user-123",
    email="user@example.com",
    username="johndoe",
    avatar="https://example.com/avatar.jpg"
)

# Sign it with your API secret (HMAC-SHA256)
sso = FastCommentsSSO.new_secure("YOUR_API_SECRET", user_data)

# Generate the SSO token to pass to the widget or an API call
sso_token = sso.create_token()

# Use this token in your frontend or pass to API calls
print(f"SSO Token: {sso_token}")

Pour un SSO simple (moins sécurisé, à des fins de 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()

Problèmes courants

401 "missing-api-key" error : Assurez‑vous de définir config.api_key = {"api_key": "YOUR_KEY"} avant de créer l'instance DefaultApi.
Wrong API class : Utilisez DefaultApi pour les requêtes authentifiées côté serveur, PublicApi pour les requêtes côté client/public, et ModerationApi pour les requêtes du tableau de bord des modérateurs.
Import errors : Assurez‑vous d'importer depuis le bon module :
- API client : from client import ...
- SSO utilities : from sso import ...

Notes

Identifiants de diffusion

Vous verrez que vous devez transmettre un broadcast_id dans certaines requêtes d'API. Lorsque vous recevez des événements, vous récupérerez cet ID, ce qui vous permet de l'ignorer si vous prévoyez d'appliquer de façon optimiste des modifications côté client (ce que vous voudrez probablement faire puisque cela offre la meilleure expérience). Passez un UUID ici. L'ID doit être suffisamment unique pour ne pas apparaître deux fois dans une session du navigateur.

Prérequis

Python >= 3.8

L'installation de base est pure-stdlib et fournit les utilitaires SSO. Le client API généré (DefaultApi/PublicApi/ModerationApi) nécessite l'extra client, qui apporte urllib3 >= 1.25.3, python-dateutil >= 2.8.2, pydantic >= 2.0.0 et typing-extensions >= 4.0.0 :

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

Agrégation

Agrège les documents en les groupant (si groupBy est fourni) et en appliquant plusieurs opérations.
Différentes opérations (p. ex. sum, countDistinct, avg, etc.) sont prises en charge.

Parameters

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

Response

Returns: AggregateResponse

Example

Exemple d'agrégation

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
# Defining the host is optional and defaults to https://fastcomments.com
# See configuration.py for a list of all supported configuration parameters.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Enter a context with an instance of the API client
with client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    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)

Récupérer les journaux d'audit

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
limit	number	query	Non
skip	number	query	Non
order	string	query	Non
after	number	query	Non
before	number	query	Non

Réponse

Renvoie : GetAuditLogsResponse

Exemple

get_audit_logs Exemple

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
# Définir l'hôte est facultatif et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé d'API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour définir le préfixe (p. ex. Bearer) pour la clé d'API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Se déconnecter (public)

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de logout_public

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Bloquer depuis un commentaire (public)

Paramètres

Nom	Type	Location	Obligatoire
tenantId	string	query	Oui
commentId	string	path	Oui
sso	string	query	Non

Réponse

Renvoie: BlockSuccess

Exemple

Exemple de 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 définition de l'hôte est optionnelle et par défaut utilise https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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 |  (optional)
    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)

Débloquer un commentaire (public)

Paramètres

Name	Type	Location	Required
tenantId	string	query	Oui
commentId	string	path	Oui
sso	string	query	Non

Réponse

Renvoie : UnblockSuccess

Exemple

Exemple de 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 définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Ouvrir un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (optionnel)
    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)

Vérifier les commentaires bloqués

Paramètres

Name	Type	Location	Required	Description
tenantId	string	query	Oui
commentIds	string	query	Oui	Une liste d'identifiants de commentaires séparés par des virgules.
sso	string	query	Non

Réponse

Renvoie : CheckBlockedCommentsResponse

Exemple

Exemple de 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
# Définir l'hôte est optionnel et la valeur par défaut est https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_ids = 'comment_ids_example' # str | Une liste d'identifiants de commentaires séparés par des virgules.
    sso = 'sso_example' # str |  (optionnel)
    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)

Bloquer un utilisateur pour un commentaire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
id	string	path	Oui
userId	string	query	Non
anonUserId	string	query	Non

Réponse

Retourne : BlockSuccess

Exemple

block_user_from_comment Exemple

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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation de clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (facultatif)
    anon_user_id = 'anon_user_id_example' # str |  (facultatif)
    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)

Créer un commentaire (public)

Parameters

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

Response

Returns: SaveCommentsResponseWithPresence

Example

Exemple 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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
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 | 
    broadcast_id = 'broadcast_id_example' # str | 
    comment_data = client.CommentData() # CommentData | 
    session_id = 'session_id_example' # str |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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)

Supprimer un commentaire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
id	string	path	Yes
contextUserId	string	query	No
isLive	boolean	query	No

Réponse

Renvoie : DeleteCommentResult

Exemple

Exemple 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
# Définir l'hôte est facultatif et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  # (optionnel)
    is_live = True # bool |  # (optionnel)
    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)

Supprimer un commentaire (public)

Parameters

Name	Type	Location	Required
tenantId	string	path	Oui
commentId	string	path	Oui
broadcastId	string	query	Oui
editKey	string	query	Non
sso	string	query	Non

Response

Renvoie : PublicAPIDeleteCommentResponse

Exemple

Exemple delete_comment_public

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
# Définir l'hôte est facultatif et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (optionnel)
    sso = 'sso_example' # str |  (optionnel)
    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)

Supprimer le vote d'un commentaire

Parameters

Nom	Type	Emplacement	Obligatoire
tenantId	string	path	Yes
commentId	string	path	Yes
voteId	string	path	Yes
urlId	string	query	Yes
broadcastId	string	query	Yes
editKey	string	query	No
sso	string	query	No

Response

Renvoie : VoteDeleteResponse

Example

Exemple 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
# La définition de l'hôte est facultative et par défaut à https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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)

Signaler un commentaire

Paramètres

Nom	Type	Emplacement	Requis
tenantId	string	query	Yes
id	string	path	Yes
userId	string	query	No
anonUserId	string	query	No

Réponse

Renvoie : FlagCommentResponse

Exemple

Exemple flag_comment

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
# Définir l’hôte est facultatif et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d’authentification et d’autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d’authentification sont fournis ci‑dessous, utilisez l’exemple qui
# correspond à votre cas d’utilisation d’authentification.
# Configurer l’autorisation de clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (p. ex. Bearer) de la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    user_id = 'user_id_example' # str |  (facultatif)
    anon_user_id = 'anon_user_id_example' # str |  (facultatif)
    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)

Récupérer un commentaire

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Oui
id	string	path	Oui

Réponse

Renvoie: APIGetCommentResponse

Exemple

Exemple de get_comment

Copy

import client
from client.models.api_get_comment_response import APIGetCommentResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation.
 
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer le texte du commentaire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	path	Oui
commentId	string	path	Oui
editKey	string	query	Non
sso	string	query	Non

Réponse

Renvoie : PublicAPIGetCommentTextResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Récupérer les noms d'utilisateurs des votes du commentaire

Paramètres

Name	Type	Emplacement	Obligatoire
tenantId	string	path	Oui
commentId	string	path	Oui
dir	integer	query	Oui
sso	string	query	Non

Réponse

Renvoie : GetCommentVoteUserNamesSuccessResponse

Exemple

Exemple de 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
# La définition de l'hôte est facultative et par défaut : https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (optional)
    try:
        api_response = api_instance.get_comment_vote_user_names(tenant_id, comment_id, dir, sso=sso)
        print("The response of PublicApi->get_comment_vote_user_names:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_comment_vote_user_names: %s\n" % e)

Récupérer des commentaires

Parameters

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
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

Response

Retourne : APIGetCommentsResponse

Example

Exemple 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
# Définir l'hôte est facultatif et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez celui qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Récupérer des commentaires (public)

req tenantId urlId

Paramètres

Nom	Type	Emplacement	Obligatoire
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

Réponse

Retourne : GetCommentsResponseWithPresencePublicComment

Exemple

Exemple 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
# Définir l'hôte est optionnel et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Enter a context with an instance of the API client
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Verrouiller un commentaire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	path	Yes
commentId	string	path	Yes
broadcastId	string	query	Yes
sso	string	query	No

Réponse

Retourne: APIEmptyResponse

Exemple

Exemple de lock_comment

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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 |  (optionnel)
    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)

Épingler un commentaire

Paramètres

Nom	Type	Emplacement	Requis
tenantId	string	path	Oui
commentId	string	path	Oui
broadcastId	string	query	Oui
sso	string	query	Non

Réponse

Renvoie : ChangeCommentPinStatusResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et a pour valeur par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (optionnel)
    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)

Enregistrer un commentaire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
isLive	boolean	query	Non
doSpamCheck	boolean	query	Non
sendEmails	boolean	query	Non
populateNotifications	boolean	query	Non

Réponse

Renvoie : APISaveCommentResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# satisfait votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du 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_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)

Enregistrer des commentaires en masse

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
isLive	boolean	query	No
doSpamCheck	boolean	query	No
sendEmails	boolean	query	No
populateNotifications	boolean	query	No

Réponse

Retourne : SaveCommentsBulkResponse

Exemple

save_comments_bulk Exemple

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
# La définition de l'hôte est facultative et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation conformément à la politique de sécurité du serveur API.
# Exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (optional)
    do_spam_check = True # bool |  (optional)
    send_emails = True # bool |  (optional)
    populate_notifications = True # bool |  (optional)
    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)

Définir le texte du commentaire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	path	Oui
commentId	string	path	Oui
broadcastId	string	query	Oui
editKey	string	query	Non
sso	string	query	Non

Réponse

Returns: PublicAPISetCommentTextResponse

Exemple

Exemple 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
# Définir l'hôte est optionnel et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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:
        print("Exception when calling PublicApi->set_comment_text: %s\n" % e)

Débloquer un utilisateur d'un commentaire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
id	string	path	Oui
userId	string	query	Non
anonUserId	string	query	Non

Réponse

Renvoie : UnblockSuccess

Exemple

Exemple de un_block_user_from_comment

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
# La définition de l'hôte est facultative et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation de clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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 |  (optionnel)
    anon_user_id = 'anon_user_id_example' # str |  (optionnel)
    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)

Retirer le signalement d'un commentaire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
id	string	path	Yes
userId	string	query	No
anonUserId	string	query	No

Réponse

Renvoie : FlagCommentResponse

Exemple

un_flag_comment Exemple

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
# La définition de l'hôte est facultative et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez celui
# qui répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Déverrouiller un commentaire

Paramètres

Name	Type	Location	Required
tenantId	string	path	Oui
commentId	string	path	Oui
broadcastId	string	query	Oui
sso	string	query	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de un_lock_comment

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et par défaut : https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (optionnel)
    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)

Désépingler un commentaire

Paramètres

Name	Type	Location	Required
tenantId	string	path	Oui
commentId	string	path	Oui
broadcastId	string	query	Oui
sso	string	query	Non

Réponse

Retourne: ChangeCommentPinStatusResponse

Exemple

Exemple de 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
# Définir l'hôte est optionnel et a pour valeur par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (facultatif)
    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)

Mettre à jour un commentaire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
id	string	path	Oui
contextUserId	string	query	Non
doSpamCheck	boolean	query	Non
isLive	boolean	query	Non

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de 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
# Définir l'hôte est facultatif et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé d'API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (p. ex. Bearer) de la clé d'API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    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 |  (optional)
    do_spam_check = True # bool |  (optional)
    is_live = True # bool |  (optional)
    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)

Voter sur un commentaire

Parameters

Nom	Type	Emplacement	Obligatoire
tenantId	string	path	Oui
commentId	string	path	Oui
urlId	string	query	Oui
broadcastId	string	query	Oui
sessionId	string	query	Non
sso	string	query	Non

Response

Renvoie : VoteResponse

Example

Exemple vote_comment

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
# Définir l'hôte est facultatif et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (optional)
    sso = 'sso_example' # str |  (optional)
    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)

Récupérer les commentaires d'un utilisateur

Paramètres

Nom	Type	Emplacement	Requis
userId	string	query	Non
direction	string	query	Non
repliesToUserId	string	query	Non
page	number	query	Non
includei10n	boolean	query	Non
locale	string	query	Non
isCrawler	boolean	query	Non

Réponse

Renvoie : GetCommentsForUserResponse

Exemple

get_comments_for_user Exemple

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
# Définir l'hôte est facultatif et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.PublicApi(api_client)
    user_id = 'user_id_example' # str |  (facultatif)
    direction = client.SortDirections() # SortDirections |  (facultatif)
    replies_to_user_id = 'replies_to_user_id_example' # str |  (facultatif)
    page = 3.4 # float |  (facultatif)
    includei10n = True # bool |  (facultatif)
    locale = 'locale_example' # str |  (facultatif)
    is_crawler = True # bool |  (facultatif)
    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("The response of PublicApi->get_comments_for_user:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->get_comments_for_user: %s\n" % e)

Ajouter une configuration de domaine

Paramètres

Name	Type	Location	Required	Description
tenantId	string	query	Oui

Réponse

Renvoie: AddDomainConfigResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la stratégie de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# convient à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour définir un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Supprimer une configuration de domaine

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui
domain	string	path	Oui

Réponse

Retourne : DeleteDomainConfigResponse

Exemple

delete_domain_config Exemple

Copy

import client
from client.models.delete_domain_config_response import DeleteDomainConfigResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer une configuration de domaine

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui
domain	string	path	Oui

Réponse

Retourne: GetDomainConfigResponse

Exemple

Exemple de get_domain_config

Copy

import client
from client.models.get_domain_config_response import GetDomainConfigResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer les configurations de domaine

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui

Réponse

Renvoie : GetDomainConfigsResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et par défaut : https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez celui
# qui correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Modifier partiellement la configuration de domaine

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui
domainToUpdate	string	path	Oui

Réponse

Renvoie : PatchDomainConfigResponse

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# convient à votre cas d'utilisation d'authentification.
# 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'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Remplacer la configuration de domaine

Paramètres

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

Réponse

Renvoie : PutDomainConfigResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous ; utilisez l'exemple
# qui correspond à votre cas d'utilisation.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (par ex. Bearer) pour la clé d'API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Créer un modèle d'e-mail

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	requête	Oui

Réponse

Renvoie: CreateEmailTemplateResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Consultez configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour définir un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Supprimer un modèle d'e-mail

Paramètres

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

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple delete_email_template

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et par défaut : https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez celui
# qui correspond à votre cas d'utilisation.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer un préfixe (p.ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Supprimer une erreur de rendu de modèle d'e-mail

Paramètres

Name	Type	Location	Required
tenantId	string	query	Oui
id	string	path	Oui
errorId	string	path	Oui

Response

Retourne : APIEmptyResponse

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# convient à votre cas d'utilisation.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer un préfixe (ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer un modèle d'e-mail

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Yes
id	string	path	Yes

Réponse

Renvoie : GetEmailTemplateResponse

Exemple

Exemple 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 définition de l'hôte est optionnelle et par défaut : https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# satisfait votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Récupérer les définitions des modèles d'e-mail

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	requête	Oui

Réponse

Renvoie : GetEmailTemplateDefinitionsResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez celui
# qui correspond à votre cas d'utilisation.
# 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'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer les erreurs de rendu des modèles d'e-mail

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
id	string	path	Oui
skip	number	query	Non

Réponse

Renvoie : GetEmailTemplateRenderErrorsResponse

Exemple

Exemple de 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 définition de l'hôte est facultative et a pour valeur par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur de l'API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurez l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    skip = 3.4 # float |  (optionnel)
    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)

Récupérer les modèles d'e-mail

Paramètres

Name	Type	Location	Required	Description
tenantId	string	query	Oui
skip	number	query	Non

Réponse

Retourne : GetEmailTemplatesResponse

Exemple

Exemple de get_email_templates

Copy

import client
from client.models.get_email_templates_response import GetEmailTemplatesResponse
from client.rest import ApiException
from pprint import pprint
# Définir l'hôte est optionnel et prend par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple
# qui correspond à votre cas d'utilisation.
 
# Configurer l'autorisation par clé API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (p.ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 3.4 # float |  (facultatif)
    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)

Générer le rendu d'un modèle d'e-mail

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Oui
locale	string	query	Non

Réponse

Renvoie : RenderEmailTemplateResponse

Exemple

Exemple de 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
# La définition de l'hôte est facultative et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la stratégie de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous ; utilisez celui
# qui répond à votre cas d'utilisation d'authentification.
# Configuration de l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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 |  (optionnel)
    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)

Mettre à jour un modèle d'e-mail

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Oui
id	string	path	Oui

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous ; utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer le journal d'événements

req tenantId urlId userIdWS

Paramètres

Name	Type	Location	Required
tenantId	string	path	Oui
urlId	string	query	Oui
userIdWS	string	query	Oui
startTime	integer	query	Oui
endTime	integer	query	Non

Réponse

Renvoie: GetEventLogResponse

Exemple

Exemple de get_event_log

Copy

import client
from client.models.get_event_log_response import GetEventLogResponse
from client.rest import ApiException
from pprint import pprint
# Définir l'hôte est optionnel et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (optionnel)
    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)

Récupérer le journal d'événements global

req tenantId urlId userIdWS

Paramètres

Nom	Type	Emplacement	Requis
tenantId	string	path	Oui
urlId	string	query	Oui
userIdWS	string	query	Oui
startTime	integer	query	Oui
endTime	integer	query	Non

Réponse

Renvoie : GetEventLogResponse

Exemple

Exemple de 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
# Définir l'hôte est optionnel et par défaut à https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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_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)

Créer une publication de flux

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
broadcastId	string	query	No
isLive	boolean	query	No
doSpamCheck	boolean	query	No
skipDupCheck	boolean	query	No

Réponse

Returns: CreateFeedPostsResponse

Exemple

Exemple 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
# Définir l'hôte est facultatif et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour définir le préfixe (ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (facultatif)
    is_live = True # bool |  (facultatif)
    do_spam_check = True # bool |  (facultatif)
    skip_dup_check = True # bool |  (facultatif)
    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)

Créer une publication de flux (public)

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	path	Oui
broadcastId	string	query	Non
sso	string	query	Non

Réponse

Renvoie : CreateFeedPostResponse

Exemple

create_feed_post_public Exemple

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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Supprimer une publication de flux (public)

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	path	Yes
postId	string	path	Yes
broadcastId	string	query	No
sso	string	query	No

Réponse

Renvoie : DeleteFeedPostPublicResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
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 | 
    post_id = 'post_id_example' # str | 
    broadcast_id = 'broadcast_id_example' # str |  (optional)
    sso = 'sso_example' # str |  (optional)
    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)

Récupérer les publications du flux

requête
tenantId
afterId

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
afterId	string	query	Non
limit	integer	query	Non
tags	array	query	Non

Réponse

Renvoie : GetFeedPostsResponse

Exemple

Exemple 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  
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com  
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.  
configuration = client.Configuration(  
    host = "https://fastcomments.com"  
)  
# Le client doit configurer les paramètres d'authentification et d'autorisation  
# conformément à la politique de sécurité du serveur API.  
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui  
# répond à votre cas d'utilisation d'authentification.  
# Configurer l'autorisation de la clé API : api_key  
configuration.api_key['api_key'] = os.environ["API_KEY"]  
# Décommentez ci-dessous pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire  
# configuration.api_key_prefix['api_key'] = 'Bearer'  
# Entrer dans un contexte avec une instance du client API  
with client.ApiClient(configuration) as api_client:  
    # Créer une instance de la 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)  

Récupérer les publications du flux (public)

req tenantId afterId

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	path	Yes
afterId	string	query	No
limit	integer	query	No
tags	array	query	No
sso	string	query	No
isCrawler	boolean	query	No
includeUserInfo	boolean	query	No

Réponse

Renvoie : PublicFeedPostsResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Récupérer les statistiques des publications du flux

Paramètres

Nom	Type	Emplacement	Requis
tenantId	string	path	Oui
postIds	array	query	Oui
sso	string	query	Non

Réponse

Retourne : FeedPostsStatsResponse

Exemple

Exemple de 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 définition de l'hôte est facultative et par défaut https://fastcomments.com
# Consultez configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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 |  (optionnel)
    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)

Récupérer les réactions d'utilisateur (public)

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	path	Oui
postIds	array	query	Non
sso	string	query	Non

Réponse

Renvoie : UserReactsResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    post_ids = ['post_ids_example'] # List[str] |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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)

Réagir à une publication de flux (public)

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	path	Yes
postId	string	path	Yes
isUndo	boolean	query	No
broadcastId	string	query	No
sso	string	query	No

Réponse

Retourne : ReactFeedPostResponse

Exemple

Exemple react_feed_post_public

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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (optionnel)
    broadcast_id = 'broadcast_id_example' # str |  (optionnel)
    sso = 'sso_example' # str |  (optionnel)
    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("The response of PublicApi->react_feed_post_public:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PublicApi->react_feed_post_public: %s\n" % e)

Mettre à jour une publication de flux

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui
id	string	path	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple 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 définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# convient à votre cas d'utilisation d'authentification.
# Configurez l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (e.g. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Mettre à jour une publication de flux (public)

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	path	Yes
postId	string	path	Yes
broadcastId	string	query	No
sso	string	query	No

Réponse

Renvoie : CreateFeedPostResponse

Exemple

Exemple de 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
# Définir l'hôte est facultatif et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Signaler un commentaire (public)

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
commentId	string	path	Oui
isFlagged	boolean	query	Oui
sso	string	query	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de flag_comment_public

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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 |  (optionnel)
    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)

Récupérer un GIF grand format

Paramètres

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

Réponse

Renvoie : GifGetLargeResponse

Exemple

Exemple 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 définition de l'hôte est optionnelle et par défaut à https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Rechercher des GIFs

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	path	Yes
search	string	query	Yes
locale	string	query	No
rating	string	query	No
page	number	query	No

Réponse

Renvoie : GetGifsSearchResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    search = 'search_example' # str | 
    locale = 'locale_example' # str |  (facultatif)
    rating = 'rating_example' # str |  (facultatif)
    page = 3.4 # float |  (facultatif)
    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)

Parameters

Nom	Type	Emplacement	Obligatoire
tenantId	string	path	Yes
locale	string	query	No
rating	string	query	No
page	number	query	No

Réponse

Renvoie : GetGifsTrendingResponse

Example

Exemple 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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    locale = 'locale_example' # str |  (facultatif)
    rating = 'rating_example' # str |  (facultatif)
    page = 3.4 # float |  (facultatif)
    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)

Ajouter un mot-clic

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui

Réponse

Renvoie : CreateHashTagResponse

Exemple

Exemple add_hash_tag

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
# Définir l'hôte est facultatif et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    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)

Ajouter des mots-clics en masse

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui

Réponse

Retourne : BulkCreateHashTagsResponse

Exemple

add_hash_tags_bulk Exemple

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
# Définir l'hôte est facultatif et a pour valeur par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Supprimer un mot-clic

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Yes
tag	string	path	Yes

Réponse

Retourne: APIEmptyResponse

Exemple

Exemple delete_hash_tag

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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
# Le client doit configurer les paramètres d'authentification et d'autorisation conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez celui qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation de clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Ouvrir un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    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)

Récupérer les mots-clics

Paramètres

Name	Type	Location	Required	Description
tenantId	string	query	Oui
page	number	query	Non

Réponse

Renvoie : GetHashTagsResponse

Exemple

Exemple get_hash_tags

Copy

import client
from client.models.get_hash_tags_response import GetHashTagsResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est facultative et par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    page = 3.4 # float |  (optionnel)
    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)

Modifier partiellement un mot-clic

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui
tag	string	path	Oui

Réponse

Retourne : UpdateHashTagResponse

Exemple

Exemple de patch_hash_tag

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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Ouvrez un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Supprimer un vote de modération

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
commentId	string	path	Oui
voteId	string	path	Oui
broadcastId	string	query	Non
sso	string	query	Non

Réponse

Renvoie : VoteDeleteResponse

Exemple

Exemple delete_moderation_vote

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
# La définition de l'hôte est facultative et par défaut à https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Récupérer les commentaires via l'API

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
page	number	query	Non
count	number	query	Non
text-search	string	query	Non
byIPFromComment	string	query	Non
filters	string	query	Non
searchFilters	string	query	Non
sorts	string	query	Non
demo	boolean	query	Non
sso	string	query	Non

Réponse

Retourne : ModerationAPIGetCommentsResponse

Exemple

Exemple get_api_comments

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
# La définition de l’hôte est facultative et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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("The response of ModerationApi->get_api_comments:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_api_comments: %s\n" % e)

Récupérer le statut d'exportation API

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
batchJobId	string	query	Non
sso	string	query	Non

Réponse

Renvoie : ModerationExportStatusResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et par défaut à https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    batch_job_id = 'batch_job_id_example' # str |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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)

Récupérer les identifiants API

Paramètres

Nom	Type	Emplacement	Obligatoire
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

Réponse

Retourne : ModerationAPIGetCommentIdsResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    text_search = 'text_search_example' # str |  (facultatif)
    by_ip_from_comment = 'by_ip_from_comment_example' # str |  (facultatif)
    filters = 'filters_example' # str |  (facultatif)
    search_filters = 'search_filters_example' # str |  (facultatif)
    after_id = 'after_id_example' # str |  (facultatif)
    demo = True # bool |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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)

Récupérer les utilisateurs bannis depuis un commentaire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
commentId	string	path	Yes
sso	string	query	No

Réponse

Renvoie : GetBannedUsersFromCommentResponse

Exemple

Exemple 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
# Définir l'hôte est facultatif et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Récupérer le statut de bannissement du commentaire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
commentId	string	path	Oui
sso	string	query	Non

Réponse

Renvoie : GetCommentBanStatusResponse

Exemple

get_comment_ban_status Exemple

Copy

import client
from client.models.get_comment_ban_status_response import GetCommentBanStatusResponse
from client.rest import ApiException
from pprint import pprint
# Définir l'hôte est facultatif et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    sso = 'sso_example' # str |  (optionnel)
    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)

Récupérer les réponses d'un commentaire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
commentId	string	path	Yes
sso	string	query	No

Réponse

Renvoie : ModerationAPIChildCommentsResponse

Exemple

Exemple 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
# Définir l'hôte est facultatif et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    sso = 'sso_example' # str |  (facultatif)
    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)

Récupérer le décompte

Paramètres

Nom	Type	Location	Obligatoire
tenantId	string	query	Oui
text-search	string	query	Non
byIPFromComment	string	query	Non
filter	string	query	Non
searchFilters	string	query	Non
demo	boolean	query	Non
sso	string	query	Non

Réponse

Renvoie : ModerationAPICountCommentsResponse

Exemple

Exemple 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
# Définir l'hôte est facultatif et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    text_search = 'text_search_example' # str |  (optionnel)
    by_ip_from_comment = 'by_ip_from_comment_example' # str |  (optionnel)
    filter = 'filter_example' # str |  (optionnel)
    search_filters = 'search_filters_example' # str |  (optionnel)
    demo = True # bool |  (optionnel)
    sso = 'sso_example' # str |  (optionnel)
    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("The response of ModerationApi->get_count:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->get_count: %s\n" % e)

Récupérer les décomptes

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui
sso	string	query	Non

Réponse

Retourne : GetBannedUsersCountResponse

Exemple

Exemple get_counts

Copy

import client
from client.models.get_banned_users_count_response import GetBannedUsersCountResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est facultative et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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_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)

Récupérer les journaux

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	requête	Oui
commentId	string	chemin	Oui
sso	string	requête	Non

Réponse

Renvoie : ModerationAPIGetLogsResponse

Exemple

Exemple get_logs

Copy

import client
from client.models.moderation_api_get_logs_response import ModerationAPIGetLogsResponse
from client.rest import ApiException
from pprint import pprint
# Définir l'hôte est facultatif et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    sso = 'sso_example' # str |  (facultatif)
    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)

Récupérer les badges manuels

Parameters

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui
sso	string	query	Non

Response

Renvoie : GetTenantManualBadgesResponse

Example

Exemple de get_manual_badges

Copy

import client
from client.models.get_tenant_manual_badges_response import GetTenantManualBadgesResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est facultative et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Récupérer les badges manuels pour un utilisateur

Parameters

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
badgesUserId	string	query	No
commentId	string	query	No
sso	string	query	No

Response

Retourne : GetUserManualBadgesResponse

Example

Exemple get_manual_badges_for_user

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
# La définition de l'hôte est facultative et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    badges_user_id = 'badges_user_id_example' # str |  (facultatif)
    comment_id = 'comment_id_example' # str |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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)

Récupérer un commentaire de modération

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
commentId	string	path	Oui
includeEmail	boolean	query	Non
includeIP	boolean	query	Non
sso	string	query	Non

Réponse

Renvoie : ModerationAPICommentResponse

Exemple

Exemple 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
# Définir l'hôte est facultatif et par défaut à https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    include_email = True # bool |  (facultatif)
    include_ip = True # bool |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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)

Récupérer le texte d'un commentaire de modération

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
commentId	string	path	Oui
sso	string	query	Non

Réponse

Renvoie : GetCommentTextResponse

Exemple

Exemple get_moderation_comment_text

Copy

import client
from client.models.get_comment_text_response import GetCommentTextResponse
from client.rest import ApiException
from pprint import pprint
# Définir l'hôte est facultatif et vaut par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    sso = 'sso_example' # str |  (optionnel)
    try:
        api_response = api_instance.get_moderation_comment_text(tenant_id, comment_id, sso=sso)
        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)

Récupérer le résumé avant bannissement

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
commentId	string	path	Yes
includeByUserIdAndEmail	boolean	query	No
includeByIP	boolean	query	No
includeByEmailDomain	boolean	query	No
sso	string	query	No

Réponse

Renvoie : PreBanSummary

Exemple

Exemple get_pre_ban_summary

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
# Définir l'hôte est facultatif et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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("La réponse de ModerationApi->get_pre_ban_summary:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception lors de l'appel de ModerationApi->get_pre_ban_summary: %s\n" % e)

Récupérer le résumé de recherche de commentaires

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
value	string	query	Non
filters	string	query	Non
searchFilters	string	query	Non
sso	string	query	Non

Réponse

Renvoie : ModerationCommentSearchResponse

Exemple

get_search_comments_summary Exemple

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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    value = 'value_example' # str |  (optional)
    filters = 'filters_example' # str |  (optional)
    search_filters = 'search_filters_example' # str |  (optional)
    sso = 'sso_example' # str |  (optional)
    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)

Récupérer les pages de recherche

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
value	string	query	Non
sso	string	query	Non

Réponse

Renvoie : ModerationPageSearchResponse

Exemple

Exemple 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
# Définir l'hôte est optionnel et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    value = 'value_example' # str |  (optionnel)
    sso = 'sso_example' # str |  (optionnel)
    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)

Récupérer les sites de recherche

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
value	string	query	Non
sso	string	query	Non

Réponse

Retourne : ModerationSiteSearchResponse

Exemple

Exemple get_search_sites

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
# Définir l'hôte est facultatif et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration supportés.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    value = 'value_example' # str | (facultatif)
    sso = 'sso_example' # str | (facultatif)
    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)

Récupérer les suggestions de recherche

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
text-search	string	query	Non
sso	string	query	Non

Réponse

Retourne : ModerationSuggestResponse

Exemple

Exemple 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
# Définir l'hôte est facultatif et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Ouvrir un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    text_search = 'text_search_example' # str |  (optional)
    sso = 'sso_example' # str |  (optional)
    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)

Récupérer les utilisateurs depuis la recherche

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
value	string	query	Non
sso	string	query	Non

Réponse

Retourne : ModerationUserSearchResponse

Exemple

Exemple get_search_users

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
# Définir l'hôte est optionnel et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    value = 'value_example' # str |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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)

Récupérer le facteur de confiance

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
userId	string	query	No
sso	string	query	No

Réponse

Renvoie : GetUserTrustFactorResponse

Exemple

Exemple 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
# La définition de l'hôte est optionnelle et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (optional)
    sso = 'sso_example' # str |  (optional)
    try:
        api_response = api_instance.get_trust_factor(tenant_id, GetTrustFactorOptions(user_id=user_id, sso=sso))
        print("La réponse de ModerationApi->get_trust_factor:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception lors de l'appel de ModerationApi->get_trust_factor : %s\n" % e)

Récupérer la préférence de bannissement de l'utilisateur

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui
sso	string	query	Non

Réponse

Renvoie : APIModerateGetUserBanPreferencesResponse

Exemple

get_user_ban_preference Exemple

Copy

import client
from client.models.api_moderate_get_user_ban_preferences_response import APIModerateGetUserBanPreferencesResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    sso = 'sso_example' # str |  (facultatif)
    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)

Récupérer le profil interne de l'utilisateur

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
commentId	string	query	No
sso	string	query	No

Réponse

Returns: GetUserInternalProfileResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Ajuster les votes d'un commentaire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
commentId	string	path	Oui
broadcastId	string	query	Non
sso	string	query	Non

Réponse

Renvoie : AdjustVotesResponse

Exemple

post_adjust_comment_votes Exemple

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
# Définir l'hôte est facultatif et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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 |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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)

Lancer une exportation via l'API

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
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

Réponse

Retourne : ModerationExportResponse

Exemple

Exemple post_api_export

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
# La définition de l'hôte est facultative et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)
    sorts = 'sorts_example' # str |  (optional)
    sso = 'sso_example' # str |  (optional)
    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)

Bannir un utilisateur depuis un commentaire

Paramètres

Nom	Type	Emplacement	Obligatoire
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

Réponse

Retourne : BanUserFromCommentResult

Exemple

Exemple post_ban_user_from_comment

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
# La définition de l'hôte est facultative et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    ban_email = True # bool |  (facultatif)
    ban_email_domain = True # bool |  (facultatif)
    ban_ip = True # bool |  (facultatif)
    delete_all_users_comments = True # bool |  (facultatif)
    banned_until = 'banned_until_example' # str |  (facultatif)
    is_shadow_ban = True # bool |  (facultatif)
    update_id = 'update_id_example' # str |  (facultatif)
    ban_reason = 'ban_reason_example' # str |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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("La réponse de ModerationApi->post_ban_user_from_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception lors de l'appel de ModerationApi->post_ban_user_from_comment : %s\n" % e)

Annuler le bannissement d'un utilisateur

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui
sso	string	query	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple post_ban_user_undo

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
# La définition de l'hôte est facultative et par défaut à https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (facultatif)
    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)

Générer un résumé pré-bannissement en masse

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
includeByUserIdAndEmail	boolean	query	Non
includeByIP	boolean	query	Non
includeByEmailDomain	boolean	query	Non
sso	string	query	Non

Réponse

Retourne : BulkPreBanSummary

Exemple

Exemple post_bulk_pre_ban_summary

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
# Définir l'hôte est facultatif et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Publier des commentaires par identifiants

Paramètres

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

Réponse

Renvoie : ModerationAPIChildCommentsResponse

Exemple

post_comments_by_ids Exemple

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
# Définir l'hôte est facultatif et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (facultatif)
    try:
        api_response = api_instance.post_comments_by_ids(tenant_id, comments_by_ids_params, sso=sso)
        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)

Signaler un commentaire (modération)

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
commentId	string	path	Yes
broadcastId	string	query	No
sso	string	query	No

Réponse

Renvoie : APIEmptyResponse

Exemple

post_flag_comment Exemple

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
# La définition de l'hôte est facultative et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (optionnel)
    sso = 'sso_example' # str |  (optionnel)
    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)

Supprimer un commentaire (modération)

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
commentId	string	path	Yes
broadcastId	string	query	No
sso	string	query	No

Réponse

Renvoie : PostRemoveCommentApiResponse

Exemple

Exemple post_remove_comment

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
# La définition de l'hôte est facultative et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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_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)

Restaurer un commentaire supprimé

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
commentId	string	path	Yes
broadcastId	string	query	No
sso	string	query	No

Réponse

Retourne : APIEmptyResponse

Exemple

post_restore_deleted_comment Exemple

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
# La définition de l’hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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)

Définir le statut d'approbation d'un commentaire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
commentId	string	path	Oui
approved	boolean	query	Non
broadcastId	string	query	Non
sso	string	query	Non

Réponse

Retourne : SetCommentApprovedResponse

Exemple

post_set_comment_approval_status Exemple

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
# Définir l'hôte est facultatif et vaut par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    approved = True # bool |  (optionnel)
    broadcast_id = 'broadcast_id_example' # str |  (optionnel)
    sso = 'sso_example' # str |  (optionnel)
    try:
        api_response = api_instance.post_set_comment_approval_status(tenant_id, comment_id, PostSetCommentApprovalStatusOptions(approved=approved, broadcast_id=broadcast_id, sso=sso))
        print("The response of ModerationApi->post_set_comment_approval_status:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->post_set_comment_approval_status: %s\n" % e)

Définir le statut de révision d'un commentaire

Paramètres

Name	Type	Location	Required
tenantId	string	query	Yes
commentId	string	path	Yes
reviewed	boolean	query	No
broadcastId	string	query	No
sso	string	query	No

Réponse

Renvoie : APIEmptyResponse

Exemple

post_set_comment_review_status Exemple

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
# Définir l'hôte est facultatif et prend par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    reviewed = True # bool |  (optional)
    broadcast_id = 'broadcast_id_example' # str |  (optional)
    sso = 'sso_example' # str |  (optional)
    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)

Définir le statut de spam d'un commentaire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
commentId	string	path	Oui
spam	boolean	query	Non
permNotSpam	boolean	query	Non
broadcastId	string	query	Non
sso	string	query	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

post_set_comment_spam_status Exemple

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
# Définir l'hôte est facultatif et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str | 
    spam = True # bool |  (facultatif)
    perm_not_spam = True # bool |  (facultatif)
    broadcast_id = 'broadcast_id_example' # str |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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)

Définir le texte d'un commentaire

Paramètres

Nom	Type	Emplacement	Requis
tenantId	string	query	Oui
commentId	string	path	Oui
broadcastId	string	query	Non
sso	string	query	Non

Réponse

Returns: SetCommentTextResponse

Exemple

Exemple post_set_comment_text

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
# Définir l'hôte est facultatif et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (optional)
    sso = 'sso_example' # str |  (optional)
    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)

Retirer le signalement d'un commentaire (modération)

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
commentId	string	path	Oui
broadcastId	string	query	Non
sso	string	query	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

post_un_flag_comment Exemple

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
# Définir l'hôte est facultatif et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (optionnel)
    sso = 'sso_example' # str |  (optionnel)
    try:
        api_response = api_instance.post_un_flag_comment(tenant_id, comment_id, PostUnFlagCommentOptions(broadcast_id=broadcast_id, sso=sso))
        print("The response of ModerationApi->post_un_flag_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ModerationApi->post_un_flag_comment: %s\n" % e)

Publier un vote (modération)

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
commentId	string	path	Oui
direction	string	query	Non
broadcastId	string	query	Non
sso	string	query	Non

Réponse

Retourne : VoteResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Attribuer un badge

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
badgeId	string	query	Oui
userId	string	query	Non
commentId	string	query	Non
broadcastId	string	query	Non
sso	string	query	Non

Réponse

Retourne : AwardUserBadgeResponse

Exemple

put_award_badge Exemple

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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (facultatif)
    comment_id = 'comment_id_example' # str |  (facultatif)
    broadcast_id = 'broadcast_id_example' # str |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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)

Fermer un fil

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
urlId	string	query	Yes
sso	string	query	No

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple put_close_thread

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Définir l'hôte est optionnel et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    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)

Retirer un badge

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
badgeId	string	query	Oui
userId	string	query	Non
commentId	string	query	Non
broadcastId	string	query	Non
sso	string	query	Non

Réponse

Renvoie : RemoveUserBadgeResponse

Exemple

put_remove_badge Exemple

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
# La définition de l'hôte est facultative et par défaut à https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (facultatif)
    comment_id = 'comment_id_example' # str |  (facultatif)
    broadcast_id = 'broadcast_id_example' # str |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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)

Rouvrir un fil

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
urlId	string	query	Yes
sso	string	query	No

Réponse

Returns: APIEmptyResponse

Exemple

Exemple put_reopen_thread

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# Définir l'hôte est facultatif et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    sso = 'sso_example' # str |  (facultatif)
    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)

Définir le facteur de confiance

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
userId	string	query	No
trustFactor	string	query	No
sso	string	query	No

Réponse

Retourne : SetUserTrustFactorResponse

Exemple

Exemple set_trust_factor

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
# Définir l'hôte est facultatif et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.ModerationApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (facultatif)
    trust_factor = 'trust_factor_example' # str |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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)

Créer un modérateur

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Oui

Réponse

Renvoie : CreateModeratorResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# convient à votre cas d'utilisation d'authentification.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Supprimer un modérateur

Paramètres

Nom	Type	Emplacement	Requis
tenantId	string	query	Oui
id	string	path	Oui
sendEmail	string	query	Non

Réponse

Retourne: APIEmptyResponse

Exemple

Exemple de delete_moderator

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est facultative et par défaut https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous; utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurez l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    send_email = 'send_email_example' # str |  (facultatif)
    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)

Récupérer un modérateur

Paramètres

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

Réponse

Renvoie : GetModeratorResponse

Exemple

Exemple de get_moderator

Copy

import client
from client.models.get_moderator_response import GetModeratorResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    try:
        api_response = api_instance.get_moderator(tenant_id, id)
        print("The response of DefaultApi->get_moderator:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_moderator: %s\n" % e)

Récupérer les modérateurs

Paramètres

Name	Type	Location	Required	Description
tenantId	string	query	Oui
skip	number	query	Non

Réponse

Renvoie : GetModeratorsResponse

Exemple

Exemple get_moderators

Copy

import client
from client.models.get_moderators_response import GetModeratorsResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est facultative et par défaut https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la stratégie de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (p.ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 3.4 # float |  (facultatif)
    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)

Envoyer une invitation

Paramètres

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

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de send_invite

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et a pour valeur par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez celui
# qui correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour définir un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Mettre à jour un modérateur

Paramètres

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

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Supprimer le compteur de notifications

Paramètres

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

Réponse

Renvoie: APIEmptyResponse

Exemple

Exemple de delete_notification_count

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer le compteur de notifications en cache

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui
id	string	path	Oui

Réponse

Renvoie : GetCachedNotificationCountResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et par défaut : https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Ouvrez un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer le nombre de notifications

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
userId	string	query	No
urlId	string	query	No
fromCommentId	string	query	No
viewed	boolean	query	No
type	string	query	No

Réponse

Renvoie : GetNotificationCountResponse

Exemple

Exemple get_notification_count

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
# Définir l'hôte est facultatif et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str |
    user_id = 'user_id_example' # str |  (optionnel)
    url_id = 'url_id_example' # str |  (optionnel)
    from_comment_id = 'from_comment_id_example' # str |  (optionnel)
    viewed = True # bool |  (optionnel)
    type = 'type_example' # str |  (optionnel)
    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)

Récupérer les notifications

Parameters

Nom	Type	Emplacement	Obligatoire
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

Réponse

Retourne : GetNotificationsResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# satisfait votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour définir le préfixe (ex. Bearer) de la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (optional)
    url_id = 'url_id_example' # str |  (optional)
    from_comment_id = 'from_comment_id_example' # str |  (optional)
    viewed = True # bool |  (optional)
    type = 'type_example' # str |  (optional)
    skip = 3.4 # float |  (optional)
    try:
        api_response = api_instance.get_notifications(tenant_id, 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)

Mettre à jour une notification

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
id	string	path	Oui
userId	string	query	Non

Réponse

Renvoie: APIEmptyResponse

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et par défaut c'est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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 |  (optionnel)
    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)

Créer une réaction de page v1

Paramètres

Nom	Type	Emplacement	Requis
tenantId	string	path	Oui
urlId	string	query	Oui
title	string	query	Non

Réponse

Renvoie : CreateV1PageReact

Exemple

Exemple de 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 définition de l'hôte est facultative et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    title = 'title_example' # str |  (optionnel)
    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)

Créer une réaction de page v2

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	path	Oui
urlId	string	query	Oui
id	string	query	Oui
title	string	query	Non

Réponse

Renvoie : CreateV1PageReact

Exemple

Exemple de 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
# Définir l'hôte est optionnel et a pour valeur par défaut https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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 |  (optional)
    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)

Supprimer une réaction de page v1

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	chemin	Oui
urlId	string	requête	Oui

Réponse

Renvoie : CreateV1PageReact

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et par défaut c'est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Ouvrir un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Supprimer une réaction de page v2

Paramètres

Nom	Type	Emplacement	Requis
tenantId	string	path	Yes
urlId	string	query	Yes
id	string	query	Yes

Réponse

Retourne: CreateV1PageReact

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Utilisez un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer les likes de page v1

Paramètres

Name	Type	Location	Required	Description
tenantId	string	path	Oui
urlId	string	query	Oui

Réponse

Retourne: GetV1PageLikes

Exemple

Exemple de get_v1_page_likes

Copy

import client
from client.models.get_v1_page_likes import GetV1PageLikes
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est facultative et la valeur par défaut est https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer les utilisateurs réagissant à la page v2

Paramètres

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

Réponse

Renvoie : GetV2PageReactUsersResponse

Exemple

Exemple de 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
# Définir l'hôte est optionnel et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer les réactions de page v2

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	path	Oui
urlId	string	query	Oui

Réponse

Renvoie : GetV2PageReacts

Exemple

Exemple 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 définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Ajouter une page

Paramètres

Name	Type	Location	Required	Description
tenantId	string	query	Oui

Réponse

Retourne: AddPageAPIResponse

Exemple

Exemple 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
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour définir un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Ouvrir un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Supprimer une page

Paramètres

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

Réponse

Renvoie: DeletePageAPIResponse

Exemple

Exemple de delete_page

Copy

import client
from client.models.delete_page_api_response import DeletePageAPIResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configure l'authentification par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer les utilisateurs hors ligne

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

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	path	Oui
urlId	string	query	Oui	Identifiant d'URL de page (nettoyé côté serveur).
afterName	string	query	Non	Curseur : passez nextAfterName de la réponse précédente.
afterUserId	string	query	Non	Curseur de résolution d'égalité : passez nextAfterUserId de la réponse précédente. Obligatoire lorsque afterName est défini afin que les égalités de nom ne suppriment pas d'entrées.

Response

Returns: PageUsersOfflineResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | Identifiant d'URL de page (nettoyé côté serveur).
    after_name = 'after_name_example' # str | Curseur : passez nextAfterName de la réponse précédente. (facultatif)
    after_user_id = 'after_user_id_example' # str | Curseur de résolution d'égalité : passez nextAfterUserId de la réponse précédente. Obligatoire lorsque afterName est défini afin que les égalités de nom ne suppriment pas d'entrées. (facultatif)
    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)

Récupérer les utilisateurs en ligne

Currently-online viewers of a page: people whose websocket session is subscribed to the page right now. Renvoie anonCount + totalCount (abonnés de la salle, y compris les visionneurs anonymes que nous n’énumérons pas).

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	chemin	Oui
urlId	string	requête	Oui	Identifiant d’URL de la page (nettoyé côté serveur).
afterName	string	requête	Non	Curseur : transmettre nextAfterName de la réponse précédente.
afterUserId	string	requête	Non	Déterminant de rupture d’égalité du curseur : transmettre nextAfterUserId de la réponse précédente. Obligatoire lorsque afterName est défini afin que les égalités de nom ne suppriment pas d’entrées.

Réponse

Renvoie : PageUsersOnlineResponse

Exemple

Exemple 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
# Définir l'hôte est facultatif et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | Identifiant d’URL de la page (nettoyé côté serveur).
    after_name = 'after_name_example' # str | Curseur : transmettre nextAfterName de la réponse précédente. (optionnel)
    after_user_id = 'after_user_id_example' # str | Déterminant de rupture d’égalité du curseur : transmettre nextAfterUserId de la réponse précédente. Obligatoire lorsque afterName est défini afin que les égalités de nom ne suppriment pas d’entrées. (optionnel)
    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)

Récupérer une page par URLid

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Oui
urlId	string	query	Oui

Réponse

Retourne : GetPageByURLIdAPIResponse

Exemple

Exemple pour get_page_by_urlid

Copy

import client
from client.models.get_page_by_urlid_api_response import GetPageByURLIdAPIResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez celui
# qui correspond à votre cas d'utilisation d'authentification.
# Configurer l'authentification par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour définir un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer les pages

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Oui

Réponse

Retourne: GetPagesAPIResponse

Exemple

Exemple de get_pages

Copy

import client
from client.models.get_pages_api_response import GetPagesAPIResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour ajouter un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    try:
        api_response = api_instance.get_pages(tenant_id)
        print("The response of DefaultApi->get_pages:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->get_pages: %s\n" % e)

Récupérer les pages (public)

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	Oui
cursor	string	query	Non	Curseur de pagination opaque renvoyé comme `nextCursor` à partir d’une requête précédente. Lié au même `sortBy`.
limit	integer	query	Non	1..200, par défaut 50 (facultatif)
q	string	query	Non	Filtre optionnel de préfixe de titre insensible à la casse.
sortBy	string	query	Non	Ordre de tri. `updatedAt` (par défaut, le plus récent d’abord), `commentCount` (le plus de commentaires d’abord), ou `title` (alphabétique).
hasComments	boolean	query	Non	Si vrai, ne renvoie que les pages contenant au moins un commentaire.

Response

Returns: GetPublicPagesResponse

Example

Exemple get_pages_public

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
# La définition de l’hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    cursor = 'cursor_example' # str | Curseur de pagination opaque renvoyé comme `nextCursor` à partir d’une requête précédente. Lié au même `sortBy`. (facultatif)
    limit = 56 # int | 1..200, par défaut 50 (facultatif)
    q = 'q_example' # str | Filtre optionnel de préfixe de titre insensible à la casse. (facultatif)
    sort_by = client.PagesSortBy() # PagesSortBy | Ordre de tri. `updatedAt` (par défaut, le plus récent d’abord), `commentCount` (le plus de commentaires d’abord), ou `title` (alphabétique). (facultatif)
    has_comments = True # bool | Si vrai, ne renvoie que les pages contenant au moins un commentaire. (facultatif)
    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)

Récupérer les informations des utilisateurs

Informations groupées sur les utilisateurs pour un locataire. Étant donné des userIds, renvoie les informations d'affichage de User / SSOUser. Utilisé par le widget de commentaires pour enrichir les utilisateurs qui viennent d'apparaître via un événement de présence. Pas de contexte de page : la confidentialité est appliquée de manière uniforme (les profils privés sont masqués).

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	path	Oui
ids	string	query	Oui	userIds séparés par des virgules.

Réponse

Renvoie : PageUsersInfoResponse

Exemple

Exemple get_users_info

Copy

import client
from client.models.page_users_info_response import PageUsersInfoResponse
from client.rest import ApiException
from pprint import pprint
# Définir l'hôte est optionnel et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    ids = 'ids_example' # str | userIds séparés par des virgules.
    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)

Modifier une page

Paramètres

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

Réponse

Renvoie : PatchPageAPIResponse

Exemple

Exemple de 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
# Définir l'hôte est optionnel et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (p.ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Supprimer un événement webhook en attente

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui
id	string	path	Oui

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de delete_pending_webhook_event

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est facultative et utilise par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous ; utilisez l'exemple qui
# correspond à votre cas d'utilisation.
# Configurez l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer le nombre d'événements webhook en attente

Paramètres

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

Réponse

Renvoie : GetPendingWebhookEventCountResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (par ex. Bearer) de la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Récupérer les événements webhook en attente

Paramètres

Nom	Type	Emplacement	Obligatoire
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

Réponse

Renvoie : GetPendingWebhookEventsResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# satisfait votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    comment_id = 'comment_id_example' # str |  (optionnel)
    external_id = 'external_id_example' # str |  (optionnel)
    event_type = 'event_type_example' # str |  (optionnel)
    type = 'type_example' # str |  (optionnel)
    domain = 'domain_example' # str |  (optionnel)
    attempt_count_gt = 3.4 # float |  (optionnel)
    skip = 3.4 # float |  (optionnel)
    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)

Créer une configuration de question

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Yes

Réponse

Retourne : CreateQuestionConfigResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et a pour valeur par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# convient à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour définir un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Supprimer une configuration de question

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui
id	string	path	Oui

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de delete_question_config

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et par défaut vaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer une configuration de question

Paramètres

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

Réponse

Retourne: GetQuestionConfigResponse

Exemple

Exemple de get_question_config

Copy

import client
from client.models.get_question_config_response import GetQuestionConfigResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est facultative et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer les configurations de questions

Paramètres

Name	Type	Location	Required	Description
tenantId	string	query	Oui
skip	number	query	Non

Réponse

Renvoie: GetQuestionConfigsResponse

Exemple

Exemple de get_question_configs

Copy

import client
from client.models.get_question_configs_response import GetQuestionConfigsResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 3.4 # float |  (optionnel)
    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)

Mettre à jour une configuration de question

Paramètres

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

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# convient à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (p.ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Ouvrez un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Créer un résultat de question

Paramètres

Name	Type	Location	Required	Description
tenantId	string	query	Oui

Réponse

Renvoie : CreateQuestionResultResponse

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et utilise par défaut https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Supprimer un résultat de question

Paramètres

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

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de delete_question_result

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et est par défaut https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous; utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurez l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer un résultat de question

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Oui
id	string	path	Oui

Réponse

Renvoie: GetQuestionResultResponse

Exemple

Exemple de get_question_result

Copy

import client
from client.models.get_question_result_response import GetQuestionResultResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez
# l'exemple qui répond à votre cas d'utilisation d'authentification.
# Configurer l'authentification par clé API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (e.g. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Récupérer les résultats de questions

Paramètres

Nom	Type	Emplacement	Requis
tenantId	string	query	Oui
urlId	string	query	Non
userId	string	query	Non
startDate	string	query	Non
questionId	string	query	Non
questionIds	string	query	Non
skip	number	query	Non

Réponse

Renvoie : GetQuestionResultsResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str |  (facultatif)
    user_id = 'user_id_example' # str |  (facultatif)
    start_date = 'start_date_example' # str |  (facultatif)
    question_id = 'question_id_example' # str |  (facultatif)
    question_ids = 'question_ids_example' # str |  (facultatif)
    skip = 3.4 # float |  (facultatif)
    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)

Mettre à jour un résultat de question

Paramètres

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

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et par défaut : https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# convient à votre cas d'utilisation.
 
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    update_question_result_body = client.UpdateQuestionResultBody() # UpdateQuestionResultBody | 
    try:
        api_response = api_instance.update_question_result(tenant_id, id, update_question_result_body)
        print("The response of DefaultApi->update_question_result:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->update_question_result: %s\n" % e)

Agréger les résultats de questions

Paramètres

Nom	Type	Emplacement	Obligatoire
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

Réponse

Renvoie : AggregateQuestionResultsResponse

Exemple

aggregate_question_results Exemple

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
# La définition de l'hôte est facultative et, par défaut, pointe vers https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous ; utilisez l'exemple qui correspond à votre cas d'utilisation.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (ex. Bearer) de la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    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)
    time_bucket = client.AggregateTimeBucket() # AggregateTimeBucket |  (optional)
    start_date = '2013-10-20T19:20:30+01:00' # datetime |  (optional)
    force_recalculate = True # bool |  (optional)
    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)

Agrégation en masse des résultats de questions

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Oui
forceRecalculate	boolean	query	Non

Réponse

Renvoie : BulkAggregateQuestionResultsResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# convient à votre cas d'utilisation d'authentification.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour définir un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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 |  (optionnel)
    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)

Combiner les commentaires avec les résultats de questions

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
questionId	string	query	Non
questionIds	array	query	Non
urlId	string	query	Non
startDate	string	query	Non
forceRecalculate	boolean	query	Non
minValue	number	query	Non
maxValue	number	query	Non
limit	number	query	Non

Réponse

Renvoie : CombineQuestionResultsWithCommentsResponse

Exemple

Exemple combine_comments_with_question_results

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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (ex. Bearer) de la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du 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)

Ajouter un utilisateur SSO

Paramètres

Name	Type	Location	Required	Description
tenantId	string	query	Oui

Réponse

Renvoie : AddSSOUserAPIResponse

Exemple

Exemple 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 définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Supprimer un utilisateur SSO

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
id	string	path	Yes
deleteComments	boolean	query	No
commentDeleteMode	string	query	No

Réponse

Renvoie : DeleteSSOUserAPIResponse

Exemple

Exemple delete_sso_user

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
# La définition de l'hôte est optionnelle et, par défaut, pointe vers https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez celui qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (ex. Bearer) de la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    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)

Récupérer un utilisateur SSO par courriel

Paramètres

Name	Type	Location	Required	Description
tenantId	string	query	Oui
email	string	path	Oui

Réponse

Renvoie: GetSSOUserByEmailAPIResponse

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer un utilisateur SSO par ID

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Oui
id	string	path	Oui

Réponse

Renvoie : GetSSOUserByIdAPIResponse

Exemple

Exemple 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 définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez celui
# qui correspond à votre cas d'utilisation.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (par exemple Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer les utilisateurs SSO

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui
skip	integer	query	Non

Réponse

Renvoie : GetSSOUsersResponse

Exemple

Exemple 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 définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez celui
# qui correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 56 # int |  (optionnel)
    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)

Modifier partiellement un utilisateur SSO

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
id	string	path	Oui
updateComments	boolean	query	Non

Réponse

Retourne: PatchSSOUserAPIResponse

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et a pour valeur par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez celui
# qui correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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 |  (optional)
    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)

Remplacer/mettre à jour un utilisateur SSO

Paramètres

Nom	Type	Emplacement	Requis
tenantId	string	query	Oui
id	string	path	Oui
updateComments	boolean	query	Non

Réponse

Renvoie : PutSSOUserAPIResponse

Exemple

Exemple pour 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
# Définir l'hôte est optionnel et utilise https://fastcomments.com par défaut
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous ; utilisez celui
# qui correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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 |  (optional)
    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)

Créer un abonnement

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Oui

Réponse

Retourne: CreateSubscriptionAPIResponse

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et par défaut : https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous ; utilisez
# l'exemple qui correspond à votre cas d'utilisation d'authentification.
# 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'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Supprimer un abonnement

Paramètres

Name	Type	Location	Required
tenantId	string	query	Oui
id	string	path	Oui
userId	string	query	Non

Réponse

Renvoie: DeleteSubscriptionAPIResponse

Exemple

Exemple de delete_subscription

Copy

import client
from client.models.delete_subscription_api_response import DeleteSubscriptionAPIResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et est https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    user_id = 'user_id_example' # str |  (optionnel)
    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)

Récupérer les abonnements

Paramètres

Name	Type	Location	Required	Description
tenantId	string	query	Oui
userId	string	query	Non

Réponse

Renvoie : GetSubscriptionsAPIResponse

Exemple

Exemple de get_subscriptions

Copy

import client
from client.models.get_subscriptions_api_response import GetSubscriptionsAPIResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'authentification par clé API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (optionnel)
    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)

Mettre à jour un abonnement

Paramètres

Name	Type	Location	Required
tenantId	string	query	Oui
id	string	path	Oui
userId	string	query	Non

Réponse

Renvoie: UpdateSubscriptionAPIResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et a pour valeur par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur d'API.
# Des exemples pour chaque méthode d'auth sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (p.ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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 |  (optionnel)
    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)

Récupérer l'utilisation quotidienne du locataire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
yearNumber	number	query	Non
monthNumber	number	query	Non
dayNumber	number	query	Non
skip	number	query	Non

Réponse

Renvoie : GetTenantDailyUsagesResponse

Exemple

Exemple 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
# La définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour définir le préfixe (p. ex. Bearer) de la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Créer un forfait pour le locataire

Paramètres

Name	Type	Location	Required	Description
tenantId	string	query	Oui

Réponse

Retourne: CreateTenantPackageResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'auth sont fournis ci‑dessous ; utilisez celui
# qui correspond à votre cas d'utilisation d'authentification.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Supprimer un forfait du locataire

Parameters

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

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de delete_tenant_package

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer un forfait du locataire

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui
id	string	path	Oui

Réponse

Renvoie : GetTenantPackageResponse

Exemple

Exemple get_tenant_package

Copy

import client
from client.models.get_tenant_package_response import GetTenantPackageResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est facultative et la valeur par défaut est https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# 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:
    # Créez une instance de la 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)

Récupérer les forfaits du locataire

Paramètres

Name	Type	Location	Required	Description
tenantId	string	query	Oui
skip	number	query	Non

Réponse

Renvoie : GetTenantPackagesResponse

Exemple

Exemple 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 définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur d'API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# convient à votre cas d'utilisation d'authentification.
# 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'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 3.4 # float |  (facultatif)
    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)

Remplacer un forfait du locataire

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Yes
id	string	path	Yes

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de 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 définition de l'hôte est facultative et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (p.ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Mettre à jour un forfait du locataire

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Oui
id	string	path	Oui

Réponse

Renvoie : APIEmptyResponse

Exemple

update_tenant_package Exemple

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 définition de l'hôte est facultative et a pour valeur par défaut https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour définir un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Créer un utilisateur du locataire

Paramètres

Name	Type	Location	Required	Description
tenantId	string	query	Oui

Réponse

Retourne: CreateTenantUserResponse

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez
# l'exemple qui satisfait votre cas d'utilisation d'authentification.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer un préfixe (ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Supprimer un utilisateur du locataire

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
id	string	path	Yes
deleteComments	string	query	No
commentDeleteMode	string	query	No

Réponse

Retourne : APIEmptyResponse

Exemple

delete_tenant_user Exemple

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
# La définition de l’hôte est optionnelle et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
# Le client doit configurer les paramètres d’authentification et d’autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d’authentification sont fournis ci‑dessus, utilisez l’exemple qui
# répond à votre cas d’utilisation d’authentification.
# Configurer l’autorisation par clé API : api_key
# Décommentez ci‑dessous pour configurer le préfixe (ex. Bearer) pour la clé API, si nécessaire
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    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)

Récupérer un utilisateur du locataire

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui
id	string	path	Oui

Réponse

Retourne : GetTenantUserResponse

Exemple

Exemple get_tenant_user

Copy

import client
from client.models.get_tenant_user_response import GetTenantUserResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est facultative et la valeur par défaut est https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer les utilisateurs du locataire

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Oui
skip	number	query	Non

Réponse

Retourne : GetTenantUsersResponse

Exemple

Exemple de get_tenant_users

Copy

import client
from client.models.get_tenant_users_response import GetTenantUsersResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous ; utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    skip = 3.4 # float |  (optionnel)
    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)

Remplacer un utilisateur du locataire

Paramètres

Nom	Type	Emplacement	Requis
tenantId	string	query	Yes
id	string	path	Yes
updateComments	string	query	No

Réponse

Retourne: APIEmptyResponse

Exemple

Exemple de 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
# Définir l'hôte est optionnel et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'authentification par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    replace_tenant_user_body = client.ReplaceTenantUserBody() # ReplaceTenantUserBody | 
    update_comments = 'update_comments_example' # str |  (optional)
    try:
        api_response = api_instance.replace_tenant_user(tenant_id, id, replace_tenant_user_body, update_comments=update_comments)
        print("The response of DefaultApi->replace_tenant_user:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->replace_tenant_user: %s\n" % e)

Paramètres

Name	Type	Location	Required
tenantId	string	query	Oui
id	string	path	Oui
redirectURL	string	query	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de send_login_link

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est facultative et par défaut sur https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Ouvrez un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    redirect_url = 'redirect_url_example' # str |  (optional)
    try:
        api_response = api_instance.send_login_link(tenant_id, id, redirect_url=redirect_url)
        print("The response of DefaultApi->send_login_link:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->send_login_link: %s\n" % e)

Mettre à jour un utilisateur du locataire

Paramètres

Name	Type	Location	Required
tenantId	string	query	Oui
id	string	path	Oui
updateComments	string	query	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et a pour valeur par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# convient à votre cas d'utilisation d'authentification.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour définir un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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 |  (optional)
    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)

Créer un locataire

Paramètres

Name	Type	Location	Required	Description
tenantId	string	query	Oui

Réponse

Renvoie : CreateTenantResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous ; utilisez
# l'exemple qui correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Supprimer un locataire

Paramètres

Nom	Type	Emplacement	Requis
tenantId	string	query	Oui
id	string	path	Oui
sure	string	query	Non

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de delete_tenant

Copy

import client
from client.models.api_empty_response import APIEmptyResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour définir un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    sure = 'sure_example' # str |  (optionnel)
    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)

Récupérer un locataire

Paramètres

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

Réponse

Renvoie : GetTenantResponse

Exemple

Exemple get_tenant

Copy

import client
from client.models.get_tenant_response import GetTenantResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est facultative et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez celui
# qui correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer les locataires

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
meta	string	query	Non
skip	number	query	Non

Réponse

Renvoie : GetTenantsResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et utilise https://fastcomments.com par défaut
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessus, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    meta = 'meta_example' # str |  (optional)
    skip = 3.4 # float |  (optional)
    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)

Mettre à jour un locataire

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Oui
id	string	path	Oui

Réponse

Retourne: APIEmptyResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# 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'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Changer l'état d'un ticket

Paramètres

Nom	Type	Emplacement	Requis
tenantId	string	query	Oui
userId	string	query	Oui
id	string	path	Oui

Réponse

Renvoie : ChangeTicketStateResponse

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurez l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str | 
    id = 'id_example' # str | 
    change_ticket_state_body = client.ChangeTicketStateBody() # ChangeTicketStateBody | 
    try:
        api_response = api_instance.change_ticket_state(tenant_id, user_id, id, change_ticket_state_body)
        print("The response of DefaultApi->change_ticket_state:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->change_ticket_state: %s\n" % e)

Créer un ticket

Paramètres

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

Réponse

Renvoie: CreateTicketResponse

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (e.g. Bearer) pour API key, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Récupérer un ticket

Paramètres

Nom	Type	Emplacement	Requis
tenantId	string	query	Oui
id	string	path	Oui
userId	string	query	Non

Réponse

Retourne : GetTicketResponse

Exemple

Exemple de get_ticket

Copy

import client
from client.models.get_ticket_response import GetTicketResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et a pour valeur par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez celui
# qui correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (p.ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    user_id = 'user_id_example' # str |  (optionnel)
    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)

Récupérer les tickets

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
userId	string	query	No
state	number	query	No
skip	number	query	No
limit	number	query	No

Réponse

Renvoie : GetTicketsResponse

Exemple

Exemple 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
# La définition de l'hôte est optionnelle et, par défaut, https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation de clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Ouvrir un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (facultatif)
    state = 3.4 # float |  (facultatif)
    skip = 3.4 # float |  (facultatif)
    limit = 3.4 # float |  (facultatif)
    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)

Récupérer les traductions

Paramètres

Nom	Type	Emplacement	Obligatoire
namespace	string	path	Yes
component	string	path	Yes
locale	string	query	No
useFullTranslationIds	boolean	query	No

Réponse

Renvoie : GetTranslationsResponse

Exemple

Exemple 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
# Définir l'hôte est facultatif et le défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Téléverser une image

Upload and resize an image

Parameters

Name	Type	Location	Required	Description
tenantId	string	path	Yes
sizePreset	string	query	No	Préréglage de taille : "Default" (1000x1000px) ou "CrossPlatform" (crée des tailles pour les appareils populaires)
urlId	string	query	No	Identifiant de page depuis lequel le téléchargement se produit, à configurer

Response

Returns: UploadImageResponse

Exemple

upload_image Exemple

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
# La définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    file = None # bytes | 
    size_preset = client.SizePreset() # SizePreset | Préréglage de taille : "Default" (1000x1000px) ou "CrossPlatform" (crée des tailles pour les appareils populaires) (optionnel)
    url_id = 'url_id_example' # str | Identifiant de page depuis lequel le téléchargement se produit, à configurer (optionnel)
    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)

Récupérer la progression du badge utilisateur par ID

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Oui
id	string	path	Oui

Réponse

Renvoie : APIGetUserBadgeProgressResponse

Exemple

Exemple de 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
# Définir l'hôte est optionnel et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# convient à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer le préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer la progression du badge utilisateur par ID d'utilisateur

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui
userId	string	path	Oui

Réponse

Renvoie : APIGetUserBadgeProgressResponse

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et par défaut : https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'auth sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour définir un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer la liste de progression des badges utilisateur

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
userId	string	query	Non
limit	number	query	Non
skip	number	query	Non

Réponse

Retourne : APIGetUserBadgeProgressListResponse

Exemple

get_user_badge_progress_list Exemple

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
# Définir l'hôte est facultatif et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation de la clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (ex. Bearer) de la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    user_id = 'user_id_example' # str |  (optionnel)
    limit = 3.4 # float |  (optionnel)
    skip = 3.4 # float |  (optionnel)
    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)

Créer un badge utilisateur

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Oui

Réponse

Renvoie : APICreateUserBadgeResponse

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple
# qui correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour définir un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Supprimer un badge utilisateur

Paramètres

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

Réponse

Renvoie : APIEmptySuccessResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et par défaut : https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur d'API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez celui
# qui correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci-dessous pour configurer un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Ouvrir un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Récupérer un badge utilisateur

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Oui
id	string	path	Oui

Réponse

Renvoie : APIGetUserBadgeResponse

Exemple

Exemple 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
# La définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour définir un préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer les badges utilisateur

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
userId	string	query	Non
badgeId	string	query	Non
type	number	query	Non
displayedOnComments	boolean	query	Non
limit	number	query	Non
skip	number	query	Non

Réponse

Renvoie : APIGetUserBadgesResponse

Exemple

Exemple 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
# Définir l'hôte est facultatif et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# répond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessus pour configurer le préfixe (p. ex. Bearer) pour la clé API, si nécessaire
# 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 |  (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)

Mettre à jour un badge utilisateur

Paramètres

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

Réponse

Renvoie : APIEmptySuccessResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et par défaut : https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer un préfixe (p.ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer le nombre de notifications de l'utilisateur

Paramètres

Nom	Type	Emplacement	Requis	Description
tenantId	string	query	Oui
sso	string	query	Non

Réponse

Renvoie : GetUserNotificationCountResponse

Exemple

Exemple de 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 définition de l'hôte est optionnelle et a pour valeur par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    sso = 'sso_example' # str |  (optionnel)
    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)

Récupérer les notifications de l'utilisateur

Paramètres

Nom	Type	Emplacement	Obligatoire	Description
tenantId	string	query	Yes
urlId	string	query	No	Utilisé pour déterminer si la page actuelle est abonnée.
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

Réponse

Renvoie : GetMyNotificationsResponse

Exemple

Exemple 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
# La définition de l'hôte est facultative et par défaut https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | Utilisé pour déterminer si la page actuelle est abonnée. (optional)
    page_size = 56 # int |  (optional)
    after_id = 'after_id_example' # str |  (optional)
    include_context = True # bool |  (optional)
    after_created_at = 56 # int |  (optional)
    unread_only = True # bool |  (optional)
    dm_only = True # bool |  (optional)
    no_dm = True # bool |  (optional)
    include_translations = True # bool |  (optional)
    include_tenant_notifications = True # bool |  (optional)
    sso = 'sso_example' # str |  (optional)
    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)

Réinitialiser le compteur de notifications de l'utilisateur

Paramètres

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

Réponse

Renvoie : ResetUserNotificationsResponse

Exemple

Exemple de 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
# La définition de l'hôte est optionnelle et par défaut : https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Ouvrez un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    sso = 'sso_example' # str |  (optionnel)
    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)

Réinitialiser les notifications de l'utilisateur

Paramètres

Nom	Type	Emplacement	Obligatoire
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

Réponse

Renvoie : ResetUserNotificationsResponse

Exemple

Exemple reset_user_notifications

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
# Définir l'hôte est facultatif et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la classe API
    api_instance = client.PublicApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    after_id = 'after_id_example' # str |  (facultatif)
    after_created_at = 56 # int |  (facultatif)
    unread_only = True # bool |  (facultatif)
    dm_only = True # bool |  (facultatif)
    no_dm = True # bool |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    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)

Mettre à jour l'abonnement aux commentaires de notification de l'utilisateur

Activer ou désactiver les notifications pour un commentaire spécifique.

Paramètres

Nom	Type	Emplacement	Requis
tenantId	string	query	Oui
notificationId	string	path	Oui
optedInOrOut	string	path	Oui
commentId	string	query	Oui
sso	string	query	Non

Réponse

Renvoie : UpdateUserNotificationCommentSubscriptionStatusResponse

Exemple

Exemple de update_user_notification_comment_subscription_status

Copy

import client
from client.models.update_user_notification_comment_subscription_status_response import UpdateUserNotificationCommentSubscriptionStatusResponse
from client.rest import ApiException
from pprint import pprint
# Définir l'hôte est optionnel et a pour valeur par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (optionnel)
    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)

Mettre à jour l'abonnement aux pages de notification de l'utilisateur

Activer ou désactiver les notifications pour une page. Lorsque les utilisateurs sont abonnés à une page, des notifications sont créées pour les nouveaux commentaires racines, et aussi

Paramètres

Nom	Type	Emplacement	Requis
tenantId	string	query	Oui
urlId	string	query	Oui
url	string	query	Oui
pageTitle	string	query	Oui
subscribedOrUnsubscribed	string	path	Oui
sso	string	query	Non

Réponse

Renvoie : UpdateUserNotificationPageSubscriptionStatusResponse

Exemple

Exemple de update_user_notification_page_subscription_status

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 définition de l'hôte est facultative et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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 |  (optionnel)
    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)

Mettre à jour le statut des notifications de l'utilisateur

Paramètres

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

Réponse

Retourne: UpdateUserNotificationStatusResponse

Exemple

Exemple de update_user_notification_status

Copy

import client
from client.models.update_user_notification_status_response import UpdateUserNotificationStatusResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et par défaut https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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 |  (facultatif)
    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)

Récupérer les statuts de présence des utilisateurs

Paramètres

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

Réponse

Renvoie : GetUserPresenceStatusesResponse

Exemple

Exemple d'utilisation de 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 définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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)

Rechercher des utilisateurs

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	path	Yes
urlId	string	query	Yes
usernameStartsWith	string	query	No
mentionGroupIds	array	query	No
sso	string	query	No
searchSection	string	query	No

Réponse

Retourne : SearchUsersResult

Exemple

Exemple 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
# La définition de l'hôte est facultative et par défaut à https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (facultatif)
    mention_group_ids = ['mention_group_ids_example'] # List[str] |  (facultatif)
    sso = 'sso_example' # str |  (facultatif)
    search_section = 'search_section_example' # str |  (facultatif)
    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)

Récupérer un utilisateur

Paramètres

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

Réponse

Renvoie : GetUserResponse

Exemple

Exemple de get_user

Copy

import client
from client.models.get_user_response import GetUserResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et par défaut est https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci-dessous, utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# 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'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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(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)

Créer un vote

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Oui
commentId	string	query	Oui
direction	string	query	Oui
userId	string	query	Non
anonUserId	string	query	Non

Réponse

Retourne : VoteResponse

Exemple

create_vote Exemple

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
# Définir l'hôte est facultatif et utilise https://fastcomments.com par défaut
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
# Le client doit configurer les paramètres d'authentification et d'autorisation conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous ; utilisez l'exemple qui
# correspond à votre cas d'utilisation d'authentification.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrer dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créer une instance de la 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 |  (facultatif)
    anon_user_id = 'anon_user_id_example' # str |  (facultatif)
    try:
        api_response = api_instance.create_vote(tenant_id, comment_id, direction, CreateVoteOptions(user_id=user_id, anon_user_id=anon_user_id))
        print("La réponse de DefaultApi->create_vote :\n")
        pprint(api_response)
    except Exception as e:
        print("Exception lors de l'appel de DefaultApi->create_vote : %s\n" % e)

Supprimer un vote

Paramètres

Name	Type	Location	Required
tenantId	string	query	Oui
id	string	path	Oui
editKey	string	query	Non

Réponse

Retourne: VoteDeleteResponse

Exemple

Exemple de delete_vote

Copy

import client
from client.models.vote_delete_response import VoteDeleteResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et par défaut utilise https://fastcomments.com
# Voir configuration.py pour la liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez l'exemple qui
# convient à votre cas d'utilisation.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer un préfixe (p.ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    id = 'id_example' # str | 
    edit_key = 'edit_key_example' # str |  (optional)
    try:
        api_response = api_instance.delete_vote(tenant_id, id, edit_key=edit_key)
        print("The response of DefaultApi->delete_vote:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DefaultApi->delete_vote: %s\n" % e)

Récupérer les votes

Paramètres

Name	Type	Location	Required	Description
tenantId	string	requête	Oui
urlId	string	requête	Oui

Réponse

Retourne : GetVotesResponse

Exemple

Exemple get_votes

Copy

import client
from client.models.get_votes_response import GetVotesResponse
from client.rest import ApiException
from pprint import pprint
# La définition de l'hôte est optionnelle et la valeur par défaut est https://fastcomments.com
# Consultez configuration.py pour la liste de tous les paramètres de configuration pris en charge.
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.
# Configurer l'autorisation par clé API : api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer un préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la 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)

Récupérer les votes pour un utilisateur

Paramètres

Nom	Type	Emplacement	Obligatoire
tenantId	string	query	Yes
urlId	string	query	Yes
userId	string	query	No
anonUserId	string	query	No

Réponse

Renvoie : GetVotesForUserResponse

Exemple

Exemple 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
# Définir l'hôte est facultatif et la valeur par défaut est https://fastcomments.com
# Voir configuration.py pour une liste de tous les paramètres de configuration pris en charge.
configuration = client.Configuration(
    host = "https://fastcomments.com"
)
# Le client doit configurer les paramètres d'authentification et d'autorisation
# conformément à la politique de sécurité du serveur API.
# Des exemples pour chaque méthode d'authentification sont fournis ci‑dessous, utilisez
# celui qui répond à votre cas d'utilisation d'authentification.
# Configure API key authorization: api_key
configuration.api_key['api_key'] = os.environ["API_KEY"]
# Décommentez ci‑dessous pour configurer le préfixe (par ex. Bearer) pour la clé API, si nécessaire
# configuration.api_key_prefix['api_key'] = 'Bearer'
# Entrez dans un contexte avec une instance du client API
with client.ApiClient(configuration) as api_client:
    # Créez une instance de la classe API
    api_instance = client.DefaultApi(api_client)
    tenant_id = 'tenant_id_example' # str | 
    url_id = 'url_id_example' # str | 
    user_id = 'user_id_example' # str |  (facultatif)
    anon_user_id = 'anon_user_id_example' # str |  (facultatif)
    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)

Besoin d'aide ?

Si vous rencontrez des problèmes ou avez des questions au sujet du SDK Python, veuillez :

Contribuer

Les contributions sont les bienvenues ! Veuillez consulter le référentiel GitHub pour les directives de contribution.

Langue 🇨🇦 Français (Canada)

Premiers pas

Documentation

Agrégation

Journaux d'audit

Authentification

Blocage depuis un commentaire

Vérifier les commentaires bloqués

Commentaires

Commentaires pour un utilisateur

Configurations de domaine

Modèles d'e-mail

Journal d'événements

Publications du flux

Signaler un commentaire

Gifs

Mots-clics

Modération

Modérateurs

Compteur de notifications

Notifications

Réactions de page

Pages

Événements webhook en attente

Configurations de questions

Résultats de questions

Agrégation des résultats de questions

Utilisateurs SSO

Abonnements

Utilisation quotidienne du locataire

Forfaits du locataire

Utilisateurs du locataire

Locataires

Tickets

Traductions

Téléverser une image

Progrès des badges utilisateur

Badges utilisateur

Notifications utilisateur

Statuts de présence utilisateur

Recherche d'utilisateurs

Utilisateurs

Votes

SDK Python de FastComments

Dépôt

Installation

Installer depuis GitHub

Contenu de la bibliothèque

API publiques vs sécurisées

Démarrage rapide

Utilisation des API authentifiées (DefaultApi)

Utilisation des API publiques (PublicApi)

Utilisation du tableau de bord de modération (ModerationApi)

Utilisation du SSO (Single Sign-On)

Problèmes courants

Notes

Identifiants de diffusion

Prérequis

Agrégation

Parameters

Response

Example

Récupérer les journaux d'audit

Paramètres

Réponse

Exemple

Se déconnecter (public)

Réponse

Exemple

Bloquer depuis un commentaire (public)

Paramètres

Réponse

Exemple

Débloquer un commentaire (public)

Paramètres

Réponse

Exemple

Vérifier les commentaires bloqués

Paramètres

Réponse