Création de packages d'activités

Étant donné que la plate-forme d'UiPath repose sur l'infrastructure .NET, toutes les activités prennent la forme d'un package Nuget (il s'agit de l'extension .nupkg que vous obtenez lors du téléchargement d'une activité directement depuis Go! vers Marketplace ou depuis les flux dans le gestionnaire de packages d'UiPath Studio). Il existe 4 types de fichiers requis pour regrouper vos fichiers dans un seul package NuGet :

Fichiers AssemblyInfo

Chaque fois que vous créez un projet dans Visual Studio, le moteur de build Microsoft (ou MSBuild) transforme le code de ce projet en DLL, une bibliothèque qui peut être utilisée par d'autres applications Windows. Les métadonnées de cette bibliothèque proviennent de trois fichiers AssemblyInfo stockés dans la section Propriétés (Properties) de votre projet et qui fournissent des informations relatives aux différents niveaux d'un ensemble d'activités. Examinons-les :

1. AssemblyInfo.cs

[assembly: AssemblyTitle("MyCompany.MyProduct.Activities")]
[assembly: AssemblyDescription("This activity was made using the UiPath Activity Set extension.")]
[assembly: ComVisible(false)]
[assembly: Guid("133E5191-68DA-4F05-9A81-D5CFA16525C8")]

AssemblyInfo.cs contient les métadonnées uniques à ce projet particulier (par ex. MyCompany.MyProduct).

• AssemblyTitle donne un nom convivial à votre DLL. Par souci de simplicité, cela doit correspondre au nom du projet.

• AssemblyDescription est un bref résumé de la nature et de l'objectif de l'assembly.

  Plusieurs autres attributs, tels que la culture ou le numéro de version, peuvent être inclus. Pour obtenir une liste complète, consultez la documentation officielle de Microsoft.

• ComVisible et Guid sont des attributs par défaut utilisés par les applications référençant la bibliothèque d'événements de ce projet. Ils restent inchangés pour la plupart des activités, mais vous pouvez en savoir plus sur leurs effets ici.

2. MyCompany.MyProductAssemblyInfo.cs

#if DEBUG
[assembly: AssemblyVersion("1.0.*")]
#else
[assembly: AssemblyVersion("1.0.0")]
#endif

Le fichier Assembly suivant, <your activity name>AssemblyInfo.cs, contient les métadonnées qui sont uniques à l'ensemble d'activités dans son ensemble mais qui sont partagées entre tous les projets ; dans ce cas, seule la version de l'activité. Notez que la version diffère pour chaque configuration Visual Studio :

• Débogage: si Visual Studio est en mode débogage, l'activité est générée avec un numéro de version 1.0.*, cela signifie que les versions majeure et mineure sont définies (1.0) et que la version du correctif est incrémentée à chaque build. Ceci est utile lorsque vous apportez des modifications fréquentes au même code, car chaque package ultérieur sera construit avec une nouvelle version, ce qui le rend facilement distinguable.

• Version: si Visual Studio est en mode de publication, le numéro de version est défini (par ex. 1.0.0). Cela offre un contrôle total lorsque vient le temps de publier officiellement un package.

  
  

  

  
  

3. GlobalAssemblyInfo.cs

[assembly: AssemblyCompany("MyCompany")]
[assembly: AssemblyProduct("Product A")]
[assembly: AssemblyCopyright("MyCompany © 2019")]
[assembly: AssemblyTrademark("MyCompany™")]
[assembly: AssemblyCulture("en-CA")]
[assembly: NeutralResourcesLanguage("en-US")]

GlobalAssemblyInfo.cs contient les métadonnées partagées entre tous les ensembles d'activités que vous produisez. Les packages UiPath.GSuite.Activities et UiPath.MicrosoftOffice365.Activities , par exemple, ont été créés par la même entreprise (UiPath), ciblent le même produit (UiPath Studio) et ont les mêmes informations de droit d' auteur, de marque déposée et de langue. Ils ont donc utilisé le même fichier GlobalAssemblyInfo.cs pour éviter les doublons inutiles.

Nuspec

Une fois que tous vos projets sont compilés dans des DLL, ces bibliothèques sont regroupées dans un package Nuget qui peut être utilisé dans UiPath Studio. Les métadonnées de ce package proviennent du fichier nuspec de votre projet de conception.

Vous pouvez voir la liste complète des éléments de métadonnées disponibles via le nuspec ici, mais jetez d'abord un œil à l'exemple de base ci-dessous. Ces éléments correspondent aux champs affichés dans le gestionnaire de packages d'UiPath Studio et permettent aux utilisateurs de rechercher et de distinguer votre ensemble d'activités.

Notez que certains éléments, tels que id et version, contiennent des balises de la forme $element$. Ceux-ci prennent leurs valeurs des balises correspondantes dans les fichiers AssemblyInfo pour éviter la duplication des informations.

<?xml version="1.0"?>
<package>
  <metadata>
    <id>$title$</id>
    <version>$version$</version>
    <title>$title$</title>
    <authors>$author$</authors>
    <owners>$author$</owners>
    <description>$description$</description>
    <copyright>$copyright$</copyright>
    <requireLicenseAcceptance>true</requireLicenseAcceptance>
    <licenseUrl>https://www.apache.org/licenses/LICENSE-2.0</licenseUrl>
    <projectUrl>https://integrations.uipath.com/docs/integrating-with-uipath</projectUrl>
    <iconUrl>https://raw.githubusercontent.com/NuGet/Samples/master/PackageIconNuspecExample/icon.png</iconUrl>
    <tags>UiPath Activit</tags>
    <dependencies>
    </dependencies>
  </metadata>
  <files>
    <file src="$OutputPath$**\)\)MyCompany.MyProduct*resources.dll" target="lib\)
et461"/>
  </files>
</package>

Remarque : si vous connaissez bien Visual Studio, vous savez peut-être qu'il est capable de créer ses propres packages Nuget en utilisant uniquement les fichiers AssemblyInfo et MSBuild. Alors, pourquoi utiliser un fichier nuspec supplémentaire ? Certaines propriétés de métadonnées, telles que les fichiers du propriétaire du package et de localisation , ne sont disponibles que dans un nuspec, c’est pourquoi nous aimons le conserver.

Métadonnées du concepteur

Une fois vos activités créées et vos concepteurs (éléments d'IU) construits, ils doivent être liés entre eux et enregistrés dans le magasin de métadonnées afin d'être affichés dans le panneau Activités (Activities) de UiPath Studio. Le code ci-dessous crée deux activités (Étendue du parent (Parent Scope) et Activité enfant (Child Activity)) en enregistrant les informations suivantes au nom de chacune d'entre elles :

• Catégorie(Category) : section du volet Activités (Activities) dans laquelle ces activités apparaîtront. Par défaut, il est défini sur MyCompany > MyProduct et peut être changé en modifiant l'attribut Category dans Resources.resx. Découvrez comment la ligne 12 relie un cours de votre projet d'activité à la catégorie spécifiée à la ligne 10.
• Concepteur: l'interface utilisateur de cette activité. Découvrez comment la ligne 13 relie une classe de votre projet d'activité à une classe de votre projet de conception.

• Documentation: documents en ligne de l'activité. Sélectionnez n'importe quelle activité dans l'un de vos workflows UiPath, appuyez sur F1, et la documentation d'aide pour cette activité s'ouvrira dans le navigateur par défaut. L'URL de cette documentation est spécifiée ici, comme à la ligne 14 (go.uipath.com est utilisé comme espace réservé).

  namespace MyCompany.MyProduct.Activities.Design
  {
      public class DesignerMetadata : IRegisterMetadata
      {
          public void Register()
          {
              var builder = new AttributeTableBuilder();
              builder.ValidateTable();
              var categoryAttribute =  new CategoryAttribute($"{Resources.Category}");
              builder.AddCustomAttributes(typeof(ParentScope), categoryAttribute);
              builder.AddCustomAttributes(typeof(ParentScope), new DesignerAttribute(typeof(ParentScopeDesigner)));
              builder.AddCustomAttributes(typeof(ParentScope), new HelpKeywordAttribute("https://go.uipath.com"));
              builder.AddCustomAttributes(typeof(ChildActivity), categoryAttribute);
              builder.AddCustomAttributes(typeof(ChildActivity), new DesignerAttribute(typeof(ChildActivityDesigner)));
              builder.AddCustomAttributes(typeof(ChildActivity), new HelpKeywordAttribute("https://go.uipath.com"));
              MetadataStore.AddAttributeTable(builder.CreateTable());
          }
      }
  }

  
  

  

  
  

Construire l'ensemble d'activités

Une fois les fichiers susmentionnés terminés, la création de l'ensemble d'activités est facile. Dans l'explorateur de solutions, cliquez simplement avec le bouton droit sur votre solution et sélectionnez Reconstruire la solution (Rebuild Solution).

Le panneau de sortie indiquera alors que les trois projets ont été générés avec succès et fournira le chemin d’accès à votre fichier nupkg groupé.

Remarque : pour créer votre package d'activités, vous pouvez également cliquer avec le bouton droit et « reconstruire » le dossier MyCompany.MyProduct ou le projet MyCompany.MyProduct.Activities.Design . Pourquoi ? Consultez la section suivante sur les scripts de post-génération.

Scripts post-construction

Accédez aux Propriétés (Properties) > Événements de construction (Build Events) de votre projet de conception et vous trouverez un script de post-génération, qui s'exécute immédiatement après la création de tous vos projets.

La première ligne de ce script supprime toutes les anciennes versions obsolètes du package qui existent dans le répertoire de sortie afin d'éviter l'encombrement.

La deuxième ligne utilise l'outil de ligne de commande NuGet (nuget.exe) pour combiner les DLL de vos 3 projets en un package NuGet lisible par UiPath Studio.

if exist $(TargetDir)Packages\)\)MyCompany.MyProduct*.* del $(TargetDir)Packages\)\)MyCompany.MyProduct*.*
if $(ConfigurationName) == Debug "$(SolutionDir).nuget\)\)NuGet.exe" pack "$(ProjectPath)" -OutputDirectory "Packages" -IncludeReferencedProjects -Prop Configuration=$(ConfigurationName)