Création de robots réutilisables

Passez en revue les instructions suivantes pour mieux comprendre comment développer des robots ou des sous-tâches réutilisables, de la conception à l'exécution.

Définir les prérequis, l'entrée, la sortie et les variables

Lorsque vous créez des robots en vue de les réutiliser, définissez les éléments suivants :

Documentez tous les prérequis nécessaires sur la manière d'utiliser votre robot de façon autonome ou en tant que sous-tâche.
Lors de la création de vos robots, définissez des valeurs d'entrée, des valeurs de sortie ou des valeurs locales. Utilisez des variables d'entrée et de sortie pour créer votre robot en vue de l'utiliser en tant que sous-tâche, de façon à ce qu'il puisse recevoir et transmettre des valeurs à ou depuis un autre robot appelant.
Fournissez des descriptions significatives lors de la définition de vos variables d'entrée et de sortie afin que les autres développeurs sachent comment interagir avec votre sous-tâche.
Respectez une norme établie pour nommer vos variables. Passez en revue les variables Automation Anywhere définies par l'utilisateur pour connaître la convention d'affectation des noms de variable. Vos variables (définies par l'utilisateur)

Suivre le principe de responsabilité unique

Les Robots développés pour être réutilisables doivent suivre le principe de responsabilité unique qui stipule que chaque sous-tâche ou composant doit gérer une seule partie de la fonctionnalité du robot global et que cette responsabilité doit être entièrement encapsulée par cette sous-tâche ou ce composant.

Autres exemples de responsabilité unique :

Sous-tâche qui traite une transaction unique, mais qui peut être appelée plusieurs fois pour chaque transaction sur une liste.
Sous-tâche qui collecte des données affichées sur l'écran d'une page unique d'un site Web, mais qui peut être appelée plusieurs fois à mesure que le robot parcourt les pages du site.

Considérations relatives à la conception de robots

Considérez les modèles suivants selon leur utilisation :

robots maîtres, principaux et secondaires
- Bot maître : ce robot est appelé directement pour lancer le processus par le biais de divers mécanismes, dont la planification via la Control Room ou un appel API. Incluez les principales étapes de processus dans la section ESSAYER :
  1. Configuration initiale du processus.
  2. Validation de la réussite de l'installation. Par exemple, vérifiez si tous les fichiers et dossiers requis existent ou si les valeurs initiales des variables sont correctes.
  3. Exécution du NETTOYAGE PRÉALABLE AU PROCESSUS sur le bureau.
  4. Appel du robot principal pour exécuter la logique métier du processus.
  Dans la section ENFIN, exécutez NETTOYAGE POSTÉRIEUR AU PROCESSUS sur le bureau.
- Bot principal robot: ce robot appelle les robots secondaires selon les besoins pour exécuter la logique métier du processus. Incluez les principales étapes de processus dans la section ESSAYER :
  1. Validation des entrées. Par exemple, valeurs des variables d'entrée du robot maître.
  2. Exécution des robots secondaires.
  3. Validation des sorties.
  4. Remplissage des valeurs de variables de sortie basées sur l'exécution du robot principal, pour revenir au robot maître.
  Dans la section CAPTURER, consignez l'erreur et vérifiez que toutes les valeurs de variables de sortie sont correctement renseignées, par exemple la valeur oStrResult à renvoyer au robot maître.
- robots secondaires
  - Un robot secondaire est appelé par le robot maître ou le robot principal pour exécuter la logique métier requise pour l'automatisation. Ces robots sont également appelés tâches d'assistance ou tâches utilitaires, car leur seule fonction est d'aider la tâche appelante.
  - Utilisez des variables de sortie pour renvoyer un indicateur de résultat au robot appelant principal ou à un autre robot secondaire. Par exemple, outStrResult. Cette valeur contient un message d'erreur si le traitement n'a pas abouti en raison d'une erreur ou d'une exception.
robots principal et secondaire : ce modèle inclut le robot maître et le robot principal au sein d'un unique robot principal. Le modèle de conception du robot secondaire est similaire au modèle de conception expliqué ci-dessus.

Ouverture et fermeture des applications

Les applications, fichiers ou fenêtres ouverts par un robot ou une sous-tâche doivent être fermés par le même robot ou la même sous-tâche.

Par exemple, lorsqu'un robot ouvre Microsoft Excel pour effectuer des opérations sur une feuille de calcul, vérifiez que la feuille de calcul et Excel sont fermés lorsque le robot a fini son traitement.
Fermez les applications lorsque l'exécution du robot a réussi ou échoué.
Utilisez le bloc Enfin de l'opération Essayer/Capturer/Enfin pour vous assurer que les applications sont fermées, que le traitement de la tâche ait réussi ou échoué.
Si certaines applications ne répondent pas pendant les tests, envisagez d'utiliser l'invite de commande pour forcer leur fermeture. Par exemple, l'opération de ligne de commande pour forcer la fermeture de PowerPoint est la suivante :
```
Taskkill /IM powerpnt.exe /F
```

Gestion des erreurs

Une fois la tâche terminée, vérifiez que le robot gère correctement les échecs et les exceptions.

Chaque tâche ou sous-tâche doit gérer ses propres erreurs.
Une exception non gérée dans une sous-tâche peut entraîner des problèmes dans une tâche parente.
Utilisez les blocs Essayer/Capturer/Enfin au niveau racine de chaque robot.
Utilisez des blocs Essayer/Capturer à l'intérieur d'une boucle si vous souhaitez lancer une opération plusieurs fois avant de signaler un échec.

Gestion des événements ou des exceptions

Outre les erreurs d'action qui sont capturées par les blocs Essayer/Capturer, vous devez effectuer des contrôles de code pour d'autres processus tels que les événements ou les exceptions. Si une certaine condition de processus se produit, notifiez ou consignez ces conditions pour une analyse supplémentaire.

Développez un Robot de tâches de gestion d'événements configurable qui minimise la nécessité de modifier le code en cas de changement des actions. Par exemple, tenez à jour un fichier XML contenant une définition de tous les événements ou exceptions possibles et les conditions de notification lorsque ces événements ou exceptions se produisent.
Dans le code, lorsque de tels événements ou exceptions se produisent, consignez les informations dans un journal d'événements. Vous pouvez également ajouter l'utilisation de la mémoire et effectuer une capture d'écran.
Exécutez le Robot de tâches de gestion d'événements pour traiter l'événement ou l'exception. Par exemple, envoyez une notification en utilisant certains paramètres du fichier XML, tels que le destinataire de l'e-mail, le destinataire Cc ou l'objet.
Si les conditions de notification varient pour chaque environnement ou changent au fil du temps, vous pouvez mettre à jour le fichier de configuration sans avoir à modifier le code.

Exécution des robots sur d'autres ordinateurs

Lorsque vous développez un robot, configurez-le de façon à ce qu'il s'exécute sur des ordinateurs autres que celui sur lequel il a été créé.

Utilisez des variables pour les chemins de fichier, les partages réseau ou les titres de fenêtre pour que votre robot puisse s'exécuter correctement sur d'autres machines.
Pensez à utiliser des valeurs globales pour les marqueurs d'environnement ou les partages réseau auxquels plusieurs robots doivent accéder.
Utilisez des caractères génériques pour les titres de fenêtre, lorsque cela est nécessaire, pour permettre aux robots de s'exécuter indépendamment de l'environnement ou de la version de l'application cible. Par exemple, au lieu d'utiliser
```
Salesforce - Professional Edition - Internet Explorer
```
utilisez :
```
Salesforce - * - Internet Explorer
```

Utilisation d'invites, de zones de message et de boucles infinies

Les invites et les zones de message arrêtent l'exécution des robots et attendent une entrée de l'utilisateur. À moins qu'une entrée de l'utilisateur ne soit requise, créez vos robots sans utiliser d'instructions d'invite.

Lorsque vous utilisez des boucles, assurez-vous que toutes les boucles ont une fin définie en définissant clairement leur nombre d'itérations ou en spécifiant des actions d'arrêt de boucle.
Si votre robot est destiné à s'exécuter comme robot non assisté, supprimez ou désactivez les invites ou les zones de message.
Si vous créez des robots pour un scénario d'automatisation assistée, les zones de message et les invites sont souvent souhaitables ou requises pour permettre aux robots de s'exécuter comme prévu. Utilisez les zones de message pour afficher différentes variables, telles que les réponses, les sorties ou les valeurs.

Stockage de données sensibles dans le Credential Vault

La Control Room inclut un Credential Vault que vous pouvez utiliser pour stocker des informations sensibles, notamment les noms d'utilisateur, les mots de passe, les clés API et les jetons.

Lors de la création d'un robot, créez une consigne dans la Control Room en utilisant le Credential Vault pour y stocker les informations d'identification et les récupérer au besoin en référençant les informations d'identification et l'attribut. Cela permet aux utilisateurs de créer des robots qui peuvent utiliser des API ou établir des connexions sans que les créateurs du robot n'aient besoin de coder en dur les informations d'identification requises.
Ne codez pas en dur les informations d'identification sensibles dans un robot ou une sous-tâche, car les informations codées en dur dans un robot présentent un risque de sécurité.
Lorsqu'il est nécessaire d'utiliser les valeurs du Credential Vault dans un robot, vérifiez que tous les noms et toutes les informations d'identification de la consigne sont clairement définis dans la documentation du robot. Si nécessaire, décrivez comment obtenir les informations d'identification, par exemple via une clé API ou un jeton.

Test des tâches indépendantes

Lorsque vous créez des robots réutilisables, concevez-les de manière à ce qu'ils puissent être testés indépendamment d'autres sous-tâches.

Mettez en pratique l'approche de développement piloté par les tests (TDD) : écrivez systématiquement un cas de test si vous ajoutez un nouveau robot ou si une application contient une nouvelle fonctionnalité.
Dans un cas de test, définissez la fonction spécifique qui valide cette fonctionnalité ou caractéristique.
Pour le principe de responsabilité unique et la réutilisation, créez de nombreuses tâches plus petites pouvant être testées indépendamment.

Utilisation des commentaires et des étapes

Les commentaires permettent aux développeurs de fournir des descriptions dans leurs robots afin que d'autres développeurs de robot puissent mieux comprendre à quoi sert chaque section, bloc de code ou sous-tâche. Incluez des commentaires clairs pour permettre aux développeurs de comprendre à quoi sert la fonction d'un bloc de code donné.

Lorsque des robots sont soumis au Bot Store, les commentaires expliquent comment personnaliser le robot.
L'utilisation de commentaires facilite la maintenance du code, car les descriptions des sections aident à identifier les parties pouvant nécessiter des modifications pour permettre aux développeurs de résoudre plus rapidement les problèmes.
Les commentaires sur les robots en cours de développement sont utiles lors de la définition d'espaces réservés pour de futurs développements. Pensez à utiliser une commande À FAIRE pour ne pas oublier d'ajouter une logique au robot ; veillez à mettre à jour les commentaires une fois le travail terminé.
Automation 360 inclut l'action Step, qui permet d'organiser le code en groupes logiques afin d'améliorer la lisibilité et l'exécution.
Créez un schéma des principaux objectifs de votre robot en utilisant des actions d'étape vides et étiquetées. Lorsque vous avez terminé, revenez à chaque étape pour développer sa logique.

Création de fichiers journaux

Sans journaux, l'identification des problèmes peut s'avérer difficile lorsque des robots s'exécutent de façon non assistée sur un certain nombre de Bot Runners. Les développeurs de logiciels, les équipes de support et les propriétaires de robots s'appuient sur les journaux pour diagnostiquer et résoudre les problèmes de leurs automatisations. Les Robots doivent consigner leurs erreurs pour fournir des détails sur ces erreurs.

Utilisez la gestion des erreurs et les captures d'écran pour mieux comprendre lorsqu'un robot ou une sous-tâche rencontre une erreur.
Utilisez le modèle A2019 du Bot Store, qui contient les fonctionnalités de base de gestion des erreurs, de journalisation et d'instantané, et indique l'emplacement de journalisation personnalisable à la racine pour la gestion des anciens fichiers journaux.
Modèle de robot Bot Store
Si nécessaire, créez des fichiers journaux supplémentaires et incluez un historique d'audit complet de toutes les activités d'un robot ou d'une sous-tâche. Ces fichiers journaux supplémentaires peuvent inclure des informations d'audit, de débogage et de performances du robot, ainsi que les informations suivantes :
- Heure de début et de fin du robot principal.
- Heure de début et de fin de la sous-tâche.
- Heure d'achèvement des étapes spécifiques définies dans le robot.
- Nombre de transactions reçues dans un fichier d'entrée.
- Nombre de transactions traitées correctement ou ayant échoué.