Geekly articles weekly

Alles für Sie: Tutorial zum Erstellen neuer Aktionen für UiPath RPA

Dieser Artikel ist ein Schulungsmaterial, das Sie durch den Prozess des Erstellens und Publizierens einer neuen Komponente für die UiPath RPA- Plattform führt. Dies ist in verschiedenen Fällen praktisch, beispielsweise für die einfache Integration in Unternehmenssysteme oder in Situationen, in denen das Unternehmen Mitarbeitern, die sich mit Programmieren nicht besonders auskennen, helfen möchte, ihre eigenen Prozesse für Roboter zu erstellen. Mir scheint, diese Technik eignet sich besonders gut für Fälle, in denen Sie Ihr Produkt in das Robotik-Ökosystem integrieren müssen, sodass Benutzer die Integration interner Prozesse mit wenigen Klicks konfigurieren können. Ein Beispiel ist der von Abbyy für das Produkt Abbyy Flexicapture Distributed geschriebene Anschluss. Ein weiteres Beispiel ist UiPath selbst, das damit die Verbindung zu seinem neuen ML-Modul für Computer Vision (Computer Vision im Paketmanager), Aktionen für die Arbeit mit PDF usw. implementiert hat.


Jetzt im UiPath Go App Store ! Bereits in vollem Gange tauchten Konnektoren zu beliebten Lösungen wie Salesforce oder ServiceNow auf, und dieser Trend gewinnt höchstwahrscheinlich erst an Popularität.


Wie fangen Sie an, Ihre eigene Aktion zu entwickeln?


NB Auf Englisch ist eine Aktion eine Aktivität. Denken Sie daran, wenn Sie etwas googeln müssen

Wenn Sie nicht alle Einstellungen vornehmen möchten, können Sie den Beispielcode ausprobieren, der in diesem Tutorial in Schritten ausgeführt wurde. Es liegt auf GitLab . Der Code im Artikel ist gekürzt und vereinfacht, er ist auf Yandex Disk verfügbar


Roboter erstellt Aktion für UiPath


Was wir brauchen, bevor wir anfangen zu arbeiten:


  1. Visual Studio (die kostenlose Version von VS Community Edition ist perfekt. Während der Installation müssen Sie .NET Desktop Development auswählen oder die folgenden Pakete manuell angeben:
    1. Nuget-Paketmanager
    2. .NET Framework 4.6.1 Targeting Pack (4.6 erforderlich)
    3. C # und Visual Basic (Aktionen können in jeder .NET-Sprache geschrieben werden, traditionell wird jedoch C # oder VB.NET verwendet). In diesem Tutorial wird C # verwendet.
    4. Windows Workflow Foundation
  2. UiPath Studio (und hier das gleiche, kostenlose CE, müssen Sie nur das Antragsformular für die UiPath Community Edition ausfüllen).
    NB Für die Entwicklung der Aktion selbst brauchen wir sie nicht, aber ich möchte natürlich sehen, was wir tun werden.
  3. NuGet Package Manager (im Lieferumfang von VS 2017+ enthalten oder von Nuget.org heruntergeladen

Beginnen Sie zu erstellen


Erstellen Sie ein Projekt in VS


  1. Erstellen Sie ein C# Class Library (.NET Framework) -Projekt. Bitte beachten Sie, dass Variationen des Themas (z. B. C # Class Library (.NET Standard) ) nicht zu uns passen.

Projekterstellungsbildschirm


  1. Wir wählen einen aussagekräftigen Namen dafür (das übliche Format <Entwickler> .UiPath.Activities. <Projektname> ) und geben an, dass wir .NET Framework 4.6.1 möchten.
    Die NuGet-Paket-ID sollte das Wort Aktivitäten enthalten. Da wir alles von VS übernehmen möchten, ist es besser, das Projekt sofort richtig zu benennen, damit Sie es später in NuGet abrufen können.

Bildschirm "Projekteinstellungen"


  1. Im erstellten Projekt erstellen wir die folgenden Unterordner (dies ist ein optionaler Schritt, aber es ist bequemer, mit Aktionspaketen zu arbeiten, wenn Sie Benutzern mehr als eine Aktion gleichzeitig zur Verfügung stellen möchten und sich die Anzahl der Dateien ansammelt):
    • Aktivitäten (hier haben wir einen Aktionscode)
    • Designer (hier haben wir die Form von Aktionsfenstern)
    • Ressourcen (hier speichern wir Bilder, Symbole und andere notwendige Dinge)
  2. Benennen Sie die Datei Class1.cs, die wir in VS erstellt haben, entsprechend dem Namen unserer ersten Aktion um und verschieben Sie sie in den Ordner Aktivitäten.

Projektordnerstruktur


Einfache Erstellung und Veröffentlichung von Aktionen


Zu diesem Zeitpunkt haben wir ein leeres Projekt in .dll kompiliert. Fahren wir nun mit der Erstellung der Aktion selbst fort.


NB Da UiPath mehrere Sprachen unterstützt, müssen wir am Ende die Lokalisierung hinzufügen und das, was wir jetzt tun, leicht ändern, aber beginnen wir mit dem, was notwendig und ausreichend ist.

  1. Wir brauchen zwei using :
     using System; using System.Activities;
  2. Wir CodeActivity unsere Klasse von CodeActivity :
     public class TutorialForHabr: CodeActivity {}
  3. Wir stellen die Eingabe- und Ausgabeparameter ein:
     public class TutorialForHabr: CodeActivity { public InArgument<Int32> Row { get; set; } public InArgument<Int32> Column { get; set; } public OutArgument<String> Cell { get; set; } }

    NB Aktionsparameter werden in InArgument< > eingegeben, InArgument< > ausgegeben und gemischt, sodass Parameter InOutArgument< > empfangen und empfangen werden InOutArgument< >
  4. Und die Execute Methode, die die einzige Methode ist, die wir definitiv festlegen müssen:
     protected override void Execute(CodeActivityContext context) { string colstr = ""; //   Row Int32 row = Row.Get(context); //   Column Int32 column = Column.Get(context); //    Excel do { column--; //26    ,    Excel,      ,  Z  AA int modn = column % 26; colstr = (char)((int)'A' + modn) + colstr; //A     Excel column /= 26; } while (column > 0); //   Cell  Cell.Set(context, colstr + row.ToString()); }

Derzeit haben wir eine Arbeitsaktion für UiPath, die einfache, aber notwendige Funktionen implementiert.
Wir werden es veröffentlichen und dann zum zweiten Teil übergehen und ein wenig „Dekorationen“ aufgreifen.


Über NuGet veröffentlichen


Sie können ein NuGet-Paket über die nuget.exe pack von NuGet Package Manager oder über die Befehlszeile nuget.exe pack indem nuget.exe pack aufrufen. Der Befehl pack akzeptiert zwei Hauptparameter als Eingabe: den Namen der Projektdatei .csproj oder den Namen der Datei .nuspec, die die Metainformationen des Pakets enthält. Die erste Option ermöglicht es uns nicht, ohne zusätzliche manuelle Änderungen der .json-Datei einige für uns wichtige Paketeigenschaften festzulegen, z. B. Tags, Lizenzen oder URLs des Repositorys. Außerdem können wir kein Symbol für das Projekt festlegen, das im Paketmanager angezeigt wird.
In der zweiten Variante duplizieren wir einige Eigenschaften des Pakets, die jedoch automatisch aus Visual Studio übernommen werden können.
Daher gehen wir den Pfad 1.5 und erstellen eine Datei mit der Erweiterung .nuspec im Projektstamm (der Name spielt keine Rolle, es gibt nur eine solche Datei), die die Informationen enthält, die nicht aus .csproj abgerufen werden können, und kombinieren diese beiden Datenquellen.


 <?xml version="1.0" encoding="utf-8"?> <package xmlns="http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd"> <metadata> <id>$id$</id> <title>$title$</title> <version>$version$</version> <authors>$author$</authors> <owners>$author$</owners> <requireLicenseAcceptance>false</requireLicenseAcceptance> <licenseUrl>https://choosealicense.com/licenses/mit/</licenseUrl> <projectUrl>https://gitlab.com/ilyak/ilyak.uipath.activities</projectUrl> <iconUrl>http://www.uipath.com/hubfs/Logos/uipath-nuget-logo.png</iconUrl> <description>$description$</description> <copyright>$copyright$</copyright> <tags>UiPath,Activity,Excel</tags> </metadata> <files> <file src="bin\Debug\IlyaK.UiPath.Activities.TutorialForHabr.dll" target="lib\net461\IlyaK.UiPath.Activities.TutorialForHabr.dll" /> </files> </package>

Wie Sie sehen können, ist die Struktur von .nuspec ziemlich offensichtlich. Wenn Sie sich nicht mit XML herumschlagen möchten, können Sie es über den visuellen Editor NuGet Package Manager erstellen und zur zukünftigen Verwendung im Projektordner speichern. Variablen wie $copyright werden aus den in der DLL-Datei enthaltenen Informationen entnommen, d. H. aus Visual Studio.
Jetzt wollen wir unsere .nuspec verwenden, damit wir mit jedem Build ein neues Paket erhalten. Dazu gehen wir zu Eigenschaften und zur Registerkarte Build-Ereignisse.
Schreiben Sie magische Wörter in eine Post-Build-Ereignisbefehlszeile

 IF EXIST "$(ProjectDir)$(OutDir)*.nupkg" del "$(ProjectDir)$(OutDir)*.nupkg" nuget.exe pack "$(ProjectPath)" IF EXIST "$(ProjectDir)$(OutDir)*.nupkg" xcopy /Y "$(ProjectDir)$(OutDir)*.nupkg" "C:\Program Files (x86)\UiPath\Studio\Packages\"

was, ins Russische übersetzt, bedeutet


  1. Löschen Sie alte Pakete in dem Ordner, in dem der Build erstellt wird
  2. Erstellen Sie ein neues Paket mit den Dateien .csproj und .nuspec
  3. Legen Sie es in den Ordner C:\Program Files (x86)\UiPath\Studio\Packages\

Was ist dieser Ordner? Dies ist das lokale Paket-Repository, das von UiPath Studio verwendet wird. Sobald dort ein neues Paket angezeigt wird, ist es automatisch über den Paketmanager verfügbar und kann den Robotisierungsprozessen hinzugefügt werden.


UiPath Studio Package Manager-Fenster


Hinweis: Der Pfad zum lokalen Repository kann über die UiPath Studio-Einstellungen geändert werden, sodass es bei Problemen mit Berechtigungen praktisch ist, Dateien dorthin zu kopieren.

UiPath Studio-Bildschirm mit der erstellten Aktion und ihren Einstellungen


Das ist eigentlich alles Glückwunsch!


Hinweis: Bitte beachten Sie, dass smart Studio selbst eine Kategorie für unsere Aktion erstellt hat, wobei Punkte als Verschachtelungsebenen verwendet werden und im Namen der Aktion Leerzeichen vor den Großbuchstaben stehen.

Der nächste Teil des Artikels befasst sich mit "Hübschheit": wie man eine visuelle Schnittstelle für eine Aktion erstellt, ein Symbol zuweist und Texte lokalisiert.


Ernst


Attribute


Damit unser Handeln funktioniert, reicht der erste Teil völlig aus. Aber ich möchte, dass wir eine Kategorie auswählen, Tipps usw. anzeigen können.
Dafür brauchen wir Attribute. Es gibt Attribute, die für die Aktion selbst und für ihre Parameter geeignet sind:


 [Category ("   ,     ")] [DisplayName ("    ")] [Description ("    ")]

Und es gibt solche, die nur Parameter benötigen:


 [RequiredArgument] //    [DefaultValue(1)] //

Lokalisierung


Leider gibt es eine Feinheit mit Attributen: In der russischen Version von UiPath Studio werden auch die Namen von Aktionskategorien und Kategorien ihrer Eigenschaften übersetzt. Wenn wir das Attribut [Category("Input")] für den Eingabeparameter festlegen, wird es in der englischen Version korrekt angezeigt, in der russischen Version jedoch in eine eigene separate Eingabekategorie und nicht in die Standardeingabekategorie. Gleiches gilt für Aktionen: In der russischen Version wird App Integration zu Application Integration .
Wir müssen also die Textkonstanten in sprachabhängige Ressourcen verschieben und von dort aus verwenden.
Erstellen Sie dazu eine magische Datei Localization.cs mit Funktionen zum Lokalisieren von Attributen


Localization.cs
 using IlyaK.UiPath.Activities.TutorialForHabr.Properties; using System; using System.ComponentModel; namespace IlyaK.UiPath.Activities.TutorialForHabr { [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Parameter | AttributeTargets.Delegate | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter)] public class LocalizedCategoryAttribute : CategoryAttribute { public LocalizedCategoryAttribute(string category) : base(category) { } protected override string GetLocalizedString(string value) { return Resources.ResourceManager.GetString(value) ?? base.GetLocalizedString(value); } } [AttributeUsage(AttributeTargets.Property | AttributeTargets.Class)] public class LocalizedDisplayNameAttribute : DisplayNameAttribute { public LocalizedDisplayNameAttribute(string displayName) : base(displayName) { } public override string DisplayName { get { return Resources.ResourceManager.GetString(DisplayNameValue) ?? base.DisplayName; } } } public class LocalizedDescriptionAttribute : DescriptionAttribute { public LocalizedDescriptionAttribute(string displayName) : base(displayName) { } public override string Description { get { return Resources.ResourceManager.GetString(DescriptionValue) ?? base.Description; } } } }

Er wird uns erlauben, das Design zu ersetzen


 [Category("Name")

auf


 [LocalizedCategory(nameof(Resources.CategoryName))]

Damit dieser Mechanismus funktioniert, müssen wir:


  1. Erstellen Sie Ressourcendateien für die Sprachen, in die wir übersetzen möchten, in unserem Fall Resources.resx und Resources.ru.resx im Ordner Resources ( Hinzufügen -> Neues Element -> Ressourcendatei ). Stellen Sie sicher, dass der Wert für den Zugriffsmodifikator für die Ressourcen " Öffentlich" ist .
  2. Zur Sammelklagedatei hinzufügen
     using IlyaK.UiPath.Activities.TutorialForHabr.Properties; //     + .Properties

  3. Und setzen Sie die Klasse und alle Parameter mit den entsprechenden Attributen


     [LocalizedCategory(nameof(Resources.AppIntegrationExcel))] [LocalizedDisplayName(nameof(Resources.TutorialForHabrName))] [LocalizedDescription(nameof(Resources.TutorialForHabrDescription))] public class TutorialForHabr : CodeActivity { [LocalizedCategory(nameof(Resources.Input))] [LocalizedDisplayName(nameof(Resources.RowName))] [LocalizedDescription(nameof(Resources.RowDescription))] public InArgument<Int32> Row { get; set; } [LocalizedCategory(nameof(Resources.Input))] [LocalizedDisplayName(nameof(Resources.ColumnName))] [LocalizedDescription(nameof(Resources.ColumnDescription))] public InArgument<Int32> Column { get; set; } [LocalizedCategory(nameof(Resources.Output))] [LocalizedDisplayName(nameof(Resources.CellName))] [LocalizedDescription(nameof(Resources.CellDescription))] }

  4. Damit die Bibliothek mit russischen Ressourcen in das NuGet-Paket fällt, müssen Sie der Dateigruppe in der .nuspec-Datei eine weitere Zeile hinzufügen
     <files> <file src="bin\Debug\IlyaK.UiPath.Activities.TutorialForHabr.dll" target="lib\net461\IlyaK.UiPath.Activities.TutorialForHabr.dll" /> <file src="bin\Debug\ru\**" target="lib\net461\ru\" /> </files>

Der Designer


Damit unsere Aktion im Prozess schön aussieht und Benutzer Daten eingeben können, ohne in Eigenschaften zu crawlen, müssen wir eine Benutzeroberfläche hinzufügen. Dies erfolgt über eine XAML-Datei, die mit Hilfe von Visual Studio in einer speziellen Oberfläche bearbeitet werden kann, ein Teil muss jedoch noch manuell repariert werden. Ich gebe Ihnen eine Vorlage, um Ihnen den Einstieg zu erleichtern. Anschließend sollte die Dokumentation von Microsoft untersucht werden.


  • Fügen Sie das Symbol für die Aktion in den Ordner Resources . In den Eigenschaften der Build-Aktion auf Ressource setzen (nicht eingebettete Ressource )
  • Erstellen Sie im Designer Ordner einen neuen Aktivitäts-Designer ( Hinzufügen -> Neues Element -> Aktivitäts-Designer ) und nennen Sie ihn TutorialForHabr

TutorialForHabr.xaml
 <sap:ActivityDesigner x:Class="IlyaK.UiPath.Activities.TutorialForHabr.Designer.TutorialForHabrDesigner" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:resource="clr-namespace:IlyaK.UiPath.Activities.TutorialForHabr.Properties" xmlns:sap="clr-namespace:System.Activities.Presentation;assembly=System.Activities.Presentation" xmlns:sapc="clr-namespace:System.Activities.Presentation.Converters;assembly=System.Activities.Presentation" xmlns:sapv="clr-namespace:System.Activities.Presentation.View;assembly=System.Activities.Presentation"> <sap:ActivityDesigner.Resources> <ResourceDictionary> <sapc:ArgumentToExpressionConverter x:Key="ArgumentToExpressionConverter" /> </ResourceDictionary> </sap:ActivityDesigner.Resources> <DockPanel Width="200"> <Grid> <Grid.ColumnDefinitions> <ColumnDefinition Width="70"></ColumnDefinition> <ColumnDefinition Width="130"></ColumnDefinition> </Grid.ColumnDefinitions> <Grid.RowDefinitions> <RowDefinition></RowDefinition> <RowDefinition></RowDefinition> </Grid.RowDefinitions> <TextBlock Grid.Row="0" Grid.Column="0" Text="{x:Static resource:Resources.RowName}" VerticalAlignment="Center" HorizontalAlignment="Right" Margin="0,0,5,0"></TextBlock> <sapv:ExpressionTextBox Grid.Row="0" Grid.Column="1" OwnerActivity="{Binding Path=ModelItem}" ExpressionType="{x:Type s:Int32}" HintText="{x:Static resource:Resources.RowDescription}" Expression="{Binding Path=ModelItem.Row, Converter={StaticResource ArgumentToExpressionConverter},ConverterParameter=In, Mode=TwoWay}"/> <TextBlock Grid.Row="1" Grid.Column="0" Text="{x:Static resource:Resources.ColumnName}" VerticalAlignment="Center" HorizontalAlignment="Right" Margin="0,0,5,0"></TextBlock> <sapv:ExpressionTextBox Grid.Row="1" Grid.Column="1" OwnerActivity="{Binding Path=ModelItem}" ExpressionType="{x:Type s:Int32}" HintText="{x:Static resource:Resources.ColumnDescription}" Expression="{Binding Path=ModelItem.Column, Converter={StaticResource ArgumentToExpressionConverter},ConverterParameter=In, Mode=TwoWay}"/> </Grid> </DockPanel> <sap:ActivityDesigner.Icon> <DrawingBrush> <DrawingBrush.Drawing> <ImageDrawing> <ImageDrawing.Rect> <Rect Location="0,0" Size="32,32" ></Rect> </ImageDrawing.Rect> <ImageDrawing.ImageSource> <BitmapImage UriSource="/IlyaK.UiPath.Activities.TutorialForHabr;component/Resources/Tutorial_32x32.png"></BitmapImage> </ImageDrawing.ImageSource> </ImageDrawing> </DrawingBrush.Drawing> </DrawingBrush> </sap:ActivityDesigner.Icon> </sap:ActivityDesigner>

So setzen wir das lokalisierte Label:


 <TextBlock Grid.Row="0" Grid.Column="0" Text="{x:Static resource:Resources.RowName}" VerticalAlignment="Center" HorizontalAlignment="Right" Margin="0,0,5,0" />

und das ist das Eingabefeld. ExpressionType legt den HintText , HintText - ein Hinweis (grauer Text) dafür. Expression HintText unserer Aktion zu


 <sapv:ExpressionTextBox OwnerActivity="{Binding Path=ModelItem}" Grid.Row="0" Grid.Column="1" ExpressionType="{x:Type s:Int32}" HintText="{x:Static resource:Resources.RowDescription}" Expression="{Binding Path=ModelItem.Row, Converter={StaticResource ArgumentToExpressionConverter},ConverterParameter=In, Mode=TwoWay}" />

Hinweis: Beachten Sie das BitmapImage-Tag am Ende der Datei. Also setzen wir das Bild für das Symbol mit einem Link zur Ressourcendatei. Dies ist eine sehr fragile Funktionalität und manchmal muss man daran basteln.

Nach den Ergebnissen sollte es so aussehen:


Action Designer Bildschirm


  • Erstellen Sie die DesignerMetata-Klasse im Ordner "Aktivitäten"

DesignerMetata.cs
 using System.Activities.Presentation.Metadata; using System.ComponentModel; namespace IlyaK.UiPath.Activities.TutorialForHabr.Design { public class DesignerMetadata : IRegisterMetadata { public void Register() { AttributeTableBuilder attributeTableBuilder = new AttributeTableBuilder(); attributeTableBuilder.AddCustomAttributes(typeof(TutorialForHabr), new DesignerAttribute(typeof(Designer.TutorialForHabrDesigner))); MetadataStore.AddAttributeTable(attributeTableBuilder.CreateTable()); } } }

  • Führen Sie den Build aus
  • Und aktualisieren Sie das Paket in UiPath Studio.
    NB Damit dies für Sie funktioniert, muss sich die Version des neuen Pakets von der Version des alten unterscheiden. Der einfachste Weg, dies zu tun, ist mit einem Visual Studio-Plugin, wie dem Build Version Increment Add-In . Oder aktualisieren Sie die Version manuell.

Hier ist die endgültige Ansicht unserer Aktion mit einem Symbol und Eingabefeldern:
Aktion beendet


Fazit


Ich hoffe, dass ich zeigen konnte, dass es nicht so lange dauert, auch vollständig gerahmte Aktionen für UiPath zu erstellen. Ich möchte wirklich, dass dieser Artikel für Sie nützlich ist und als guter Anfang für das Schreiben neuer und wunderbarer Aktivitäten für UiPath dient. Und wenn Sie es erstellen - vergessen Sie nicht, es auf UiPath Go!


Zusätzliche Materialien


Source: https://habr.com/ru/post/de453510/

More articles:


All Articles