> ## Documentation Index
> Fetch the complete documentation index at: https://ai-kb.automationanywhere.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Déclencheurs principaux

> Déclencheurs à usage général pour les exécutions manuelles, l'exécution planifiée, les requêtes HTTP et les téléchargements de fichiers.

Les déclencheurs principaux couvrent les points d'entrée de flux de travail les plus courants : l'invocation manuelle, les exécutions planifiées, les requêtes HTTP entrantes et les téléchargements de fichiers.

## Saisie manuelle

Démarre un flux de travail lorsqu'un utilisateur ou un système externe l'invoque explicitement. Vous pouvez le configurer avec des champs d'entrée personnalisés qui doivent être remplis avant l'exécution du flux de travail — le rendant idéal pour les tâches à la demande qui nécessitent un contexte fourni par l'utilisateur, comme la soumission d'une demande, le démarrage d'un rapport ou l'initiation d'un processus depuis l'interface de chat Odin.

**Quand l'utiliser**

* Vous souhaitez exécuter un flux de travail à la demande depuis l'interface utilisateur Odin ou via l'API.
* Le flux de travail a besoin d'entrées fournies par l'utilisateur avant de pouvoir s'exécuter.
* Vous testez ou déboguez un flux de travail avec des valeurs spécifiques.

**Configuration**

| Champ           | Type | Description                                                                                                                                                                                          |
| --------------- | ---- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Champs d'entrée | Any  | Paramètres définis par l'utilisateur configurés dans les paramètres du déclencheur. Chaque champ a un nom, un type et une description optionnelle affichée à l'utilisateur au moment de l'exécution. |

**Variables de sortie**

| Variable                 | Description                                                                                                                                |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ |
| `trigger.user_input`     | Le texte brut soumis par l'utilisateur.                                                                                                    |
| `trigger.inputs.<field>` | La valeur de chaque champ d'entrée nommé. Remplacez `<field>` par le nom du champ configuré (par exemple, `trigger.inputs.customer_name`). |
| `trigger.chat_id`        | L'ID de la session de chat qui a initié l'exécution.                                                                                       |
| `trigger.message_id`     | L'ID du message qui a déclenché le flux de travail.                                                                                        |

```text Exemple : référencer un champ d'entrée theme={null}
Bonjour {{ trigger.inputs.customer_name }}, votre demande a été reçue.
```

<AccordionGroup>
  <Accordion title="Notes">
    * Les champs d'entrée sont présentés à l'utilisateur comme un formulaire avant le démarrage du flux de travail. Gardez les noms de champs courts et descriptifs.
    * `trigger.user_input` est disponible même si aucun champ d'entrée personnalisé n'est configuré.
    * Pour invoquer ce déclencheur par programme, appelez l'API Odin avec l'ID du flux de travail et les valeurs d'entrée requises.
  </Accordion>
</AccordionGroup>

## Webhook

Expose un point de terminaison HTTP unique pour votre flux de travail. Les systèmes externes — tels que les applications tierces, les plateformes d'automatisation ou les scripts personnalisés — peuvent envoyer une requête HTTP à cette URL pour démarrer le flux de travail. Le corps de la requête, les en-têtes, les paramètres de requête et la méthode HTTP sont tous transmis aux nœuds en aval.

**Quand l'utiliser**

* Un système externe doit notifier Odin lorsqu'un événement se produit (par exemple, une soumission de formulaire, un événement de paiement ou une mise à jour d'une autre plateforme).
* Vous intégrez Odin avec Automation Anywhere ou un autre système qui peut appeler un point de terminaison HTTP.
* Vous souhaitez exposer un flux de travail comme point de terminaison API que d'autres développeurs ou outils peuvent appeler.

**Configuration**

| Paramètre       | Type   | Description                                                                                                                                                          |
| --------------- | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `http_method`   | String | La méthode HTTP que le point de terminaison acceptera : `GET`, `POST`, `PUT`, `PATCH` ou `DELETE`.                                                                   |
| `auth_type`     | String | Comment les requêtes entrantes sont authentifiées : `none`, `basic` ou `header`.                                                                                     |
| `response_mode` | String | `onReceived` retourne un HTTP 200 immédiat dès l'arrivée de la requête. `lastNode` attend la fin du flux de travail et retourne la sortie finale comme réponse HTTP. |

**Variables de sortie**

| Variable              | Description                                                                                                            |
| --------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| `trigger.body`        | Le corps JSON de la requête entrante.                                                                                  |
| `trigger.headers`     | Les en-têtes HTTP envoyés avec la requête.                                                                             |
| `trigger.query`       | Les paramètres de requête d'URL depuis la requête.                                                                     |
| `trigger.method`      | La méthode HTTP utilisée par l'appelant.                                                                               |
| `trigger.webhook_url` | L'URL complète du point de terminaison webhook. Partagez ceci avec le système externe qui appelera le flux de travail. |

**Modes de réponse**

| Mode         | Comportement                                                                                                                                                                                         |
| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `onReceived` | Retourne HTTP `200 OK` immédiatement à l'arrivée de la requête, avant la fin du flux de travail. À utiliser pour les scénarios de type « déclencher et oublier ».                                    |
| `lastNode`   | Maintient la connexion HTTP ouverte jusqu'à la fin du flux de travail, puis retourne la sortie du dernier nœud comme corps de réponse. À utiliser lorsque l'appelant attend un flux utile synchrone. |

<AccordionGroup>
  <Accordion title="Notes">
    * Lors de l'utilisation de l'authentification `header`, configurez le nom d'en-tête et la valeur attendus dans les paramètres du déclencheur.
    * `trigger.webhook_url` est utile pour inclure l'URL du point de terminaison dans la documentation de configuration envoyée aux partenaires d'intégration.
    * Si vous appelez ce webhook depuis Automation Anywhere, utilisez l'action **HTTP Task** dans votre bot pour effectuer une POST vers l'URL du webhook.
  </Accordion>
</AccordionGroup>

## Planification

Déclenche automatiquement un flux de travail selon un calendrier récurrent défini par une expression cron. Utilisez-la pour automatiser les tâches basées sur le temps, telles que les rapports quotidiens, les synchronisations de données périodiques ou les notifications récurrentes — sans aucune intervention manuelle.

**Quand l'utiliser**

* Vous avez besoin qu'un flux de travail s'exécute à une heure fixe chaque jour, semaine ou mois.
* Vous automatisez un processus métier récurrent (par exemple, extraire les données chaque matin, envoyer un résumé hebdomadaire).
* Vous souhaitez interroger un système externe à intervalles réguliers.

**Configuration**

| Paramètre  | Type   | Description                                                                                                                                    |
| ---------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| `schedule` | String | Une expression cron définissant quand le flux de travail s'exécute.                                                                            |
| `timezone` | String | Le fuseau horaire dans lequel l'expression cron est évaluée. Accepte les noms de fuseau horaire standard tels que `UTC` ou `America/New_York`. |

<Warning>
  Définissez toujours le champ `timezone` explicitement. S'il n'est pas défini, le calendrier s'exécute en UTC, ce qui peut causer une synchronisation inattendue pour les flux de travail spécifiques à une région.
</Warning>

**Référence des expressions cron**

Une expression cron a cinq champs : **minute · heure · jour du mois · mois · jour de la semaine**.

```text theme={null}
┌───── minute (0–59)
│ ┌───── heure (0–23)
│ │ ┌───── jour du mois (1–31)
│ │ │ ┌───── mois (1–12)
│ │ │ │ ┌───── jour de la semaine (0–6, dimanche = 0)
│ │ │ │ │
* * * * *
```

| Expression     | Planification                      |
| -------------- | ---------------------------------- |
| `0 9 * * *`    | Tous les jours à 9h00              |
| `0 9 * * 1`    | Tous les lundis à 9h00             |
| `0 */6 * * *`  | Toutes les 6 heures                |
| `0 8 1 * *`    | Premier jour de chaque mois à 8h00 |
| `*/15 * * * *` | Toutes les 15 minutes              |

**Variables de sortie**

| Variable                      | Description                                                       |
| ----------------------------- | ----------------------------------------------------------------- |
| `trigger.trigger_time`        | L'horodatage ISO 8601 du moment où le calendrier s'est déclenché. |
| `trigger.schedule_expression` | L'expression cron utilisée pour cette exécution.                  |
| `trigger.trigger_type`        | Toujours `"schedule"`.                                            |

<AccordionGroup>
  <Accordion title="Notes">
    * Le déclencheur Schedule ne transmet pas d'entrée utilisateur. Si votre flux de travail a besoin de données dynamiques, récupérez-les dans le flux de travail en utilisant un nœud API ou un outil du kit à outils.
    * Utilisez `trigger.trigger_time` dans les nœuds en aval pour horodater les enregistrements ou journaliser quand l'exécution planifiée s'est produite.
  </Accordion>
</AccordionGroup>

## Téléchargement de fichier

Démarre un flux de travail lorsqu'un ou plusieurs fichiers sont téléchargés. Il fournit le contenu, le nom, la taille et le type MIME de chaque fichier aux nœuds en aval — le rendant idéal pour les flux de travail de traitement de documents tels que l'analyse d'un rapport téléchargé, l'extraction de données d'une feuille de calcul ou l'acheminement d'un fichier vers un modèle IA pour analyse.

**Quand l'utiliser**

* Vous souhaitez que les utilisateurs soumettent des fichiers pour que le flux de travail les traite (par exemple, factures, contrats, exports CSV).
* Vous devez extraire le contenu des documents téléchargés et le transmettre à un nœud LLM ou de traitement de données.
* Vous construisez un pipeline d'ingestion multi-fichiers.

**Configuration**

Ce déclencheur n'a pas de champs de configuration requis. Il s'active automatiquement lorsqu'un fichier est téléchargé vers le chat ou l'interface associée au flux de travail.

**Variables de sortie**

<Tabs>
  <Tab title="Fichier unique">
    | Variable               | Description                                                                |
    | ---------------------- | -------------------------------------------------------------------------- |
    | `trigger.file.content` | Le contenu texte entièrement extrait du fichier téléchargé.                |
    | `trigger.file.name`    | Le nom de fichier d'origine.                                               |
    | `trigger.file.size`    | La taille du fichier en octets.                                            |
    | `trigger.file.type`    | Le type MIME (par exemple, `application/pdf`, `text/csv`).                 |
    | `trigger.file_count`   | Nombre total de fichiers téléchargés. Retourne `1` pour un fichier unique. |
  </Tab>

  <Tab title="Fichiers multiples">
    | Variable             | Description                                                                                               |
    | -------------------- | --------------------------------------------------------------------------------------------------------- |
    | `trigger.files`      | Un tableau de tous les fichiers téléchargés. Chaque élément contient `content`, `name`, `size` et `type`. |
    | `trigger.file_count` | Nombre total de fichiers téléchargés.                                                                     |

    Utilisez un nœud **Loop** pour parcourir `trigger.files` lors du traitement de plusieurs téléchargements dans une seule exécution.
  </Tab>
</Tabs>

<Note>
  Le contenu du fichier est extrait en tant que texte brut. Les formats binaires tels que les PDF et les documents Word sont analysés automatiquement — le texte extrait est ce qui apparaît dans `trigger.file.content`.
</Note>

<AccordionGroup>
  <Accordion title="Notes">
    * `trigger.file` fait toujours référence au premier fichier (ou seul) téléchargé. Pour les flux de travail multi-fichiers, utilisez `trigger.files` avec un nœud Loop.
    * Utilisez `trigger.file.type` dans un nœud Conditional pour acheminer différents types de fichiers vers différentes branches de traitement.
  </Accordion>
</AccordionGroup>
