Geekly articles weekly

Todo seu: Tutorial sobre como criar novas ações para o UiPath RPA

Este artigo é um tutorial que mostra o processo de criação e publicação de um novo componente para a plataforma UiPath RPA . Isso é conveniente em diferentes casos, por exemplo, para uma integração simples com os sistemas da empresa ou em situações em que a empresa deseja ajudar os funcionários que não têm um conhecimento especial em programação a criar seus próprios processos para robôs. Mas, parece-me, essa técnica funciona especialmente bem nos casos em que você precisa integrar seu produto ao ecossistema de robótica, permitindo que os usuários configurem a integração de processos internos em apenas alguns cliques. Um exemplo é o conector escrito pela Abbyy para o seu produto Abbyy Flexicapture Distributed . Outro exemplo é o próprio UiPath, que implementou a conexão com seu novo módulo ML para visão computacional (Computer Vision no gerenciador de pacotes), ações para trabalhar com PDF etc.


Agora na loja de aplicativos UiPath Go! já em pleno andamento começaram a aparecer conectores para soluções populares, como Salesforce ou ServiceNow, e, muito provavelmente, essa tendência está apenas ganhando popularidade.


Então, como você começa a desenvolver sua própria ação?


NB Em inglês, uma ação é uma atividade, lembre-se disso se precisar pesquisar algo no Google

Se você não deseja lidar com todas as configurações, tente o código de exemplo feito nas etapas deste tutorial. Encontra-se no GitLab . O código no artigo é reduzido e simplificado, está disponível no Yandex Disk


Robô cria ação para o UiPath


O que precisamos antes de começarmos a trabalhar:


  1. Visual Studio (a versão gratuita do VS Community Edition é perfeita. Durante a instalação, você deve selecionar .NET Desktop Development ou especificar manualmente os seguintes pacotes:
    1. Gerenciador de pacotes Nuget
    2. Pacote de direcionamento do .NET Framework 4.6.1 (4.6 necessário)
    3. C # e Visual Basic (as ações podem ser escritas em qualquer linguagem .NET, mas, tradicionalmente, C # ou VB.NET é usado). Este tutorial usará C #.
    4. Fundação de fluxo de trabalho do Windows
  2. UiPath Studio (e aqui a mesma coisa, CE grátis, você só precisa preencher o aplicativo UiPath Community Edition ).
    NB: Para o desenvolvimento da ação em si, não precisamos dela, mas, é claro, quero ver o que faremos.
  3. NuGet Package Manager (incluído no VS 2017+ ou baixado do Nuget.org

Comece a criar


Crie um projeto no VS


  1. Crie um projeto da C# Class Library (.NET Framework) . Observe que variações no tema (por exemplo, C # Class Library (.NET Standard) ) não são adequadas para nós.

Tela de criação de projeto


  1. Escolhemos um nome significativo para ele (o formato usual <Developer> .UiPath.Activities. <Nome do Projeto> ) e indicamos que queremos usar o .NET Framework 4.6.1 .
    O ID do pacote NuGet deve conter a palavra Atividades. Como queremos usar tudo do VS, é melhor nomear o projeto imediatamente corretamente, para que você possa buscá-lo no NuGet mais tarde.

Tela de configurações do projeto


  1. No projeto criado, criamos as seguintes subpastas (esta é uma etapa opcional, mas é mais conveniente trabalhar com pacotes de ação quando você deseja fornecer aos usuários mais de uma ação por vez e o número de arquivos começa a acumular):
    • Atividades (aqui teremos um código de ação)
    • Designer (aqui teremos a forma de janelas de ação)
    • Recursos (aqui vamos armazenar fotos, ícones e outras coisas necessárias)
  2. Renomeie o arquivo Class1.cs que, para nós, foi criado no VS de acordo com o nome da nossa primeira ação e mova-o para a pasta Atividades.

Estrutura de pastas do projeto


Fácil criação e publicação de ações


Neste ponto, temos um projeto vazio compilado em .dll . Agora vamos criar a ação em si.


NB Como o UiPath suporta vários idiomas, no final, precisaremos adicionar localização e alterar levemente o que estamos fazendo agora, mas vamos começar com o que é necessário e suficiente.

  1. Precisamos de dois using :
     using System; using System.Activities;
  2. CodeActivity nossa classe de CodeActivity :
     public class TutorialForHabr: CodeActivity {}
  3. Definimos os parâmetros de entrada e saída:
     public class TutorialForHabr: CodeActivity { public InArgument<Int32> Row { get; set; } public InArgument<Int32> Column { get; set; } public OutArgument<String> Cell { get; set; } }

    Nota: Os parâmetros de ação são entrada InArgument< > , saída OutArgument< > e misturados, permitindo que ambos recebam e recebam parâmetros InOutArgument< >
  4. E o método Execute , que é o único método que devemos definir definitivamente:
     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()); }

Nesta fase, temos uma ação de trabalho para o UiPath que implementa funcionalidades simples, mas necessárias.
Vamos publicá-lo e, em seguida, passamos para a segunda parte e abordamos um pouco as “decorações”.


Publicar via NuGet


Você pode criar um pacote NuGet por meio da GUI do NuGet Package Manager ou da linha de comando chamando o nuget.exe pack . O comando pack aceita dois parâmetros principais como entrada: o nome do arquivo do projeto .csproj ou o nome do arquivo .nuspec que contém as metainformações do pacote. A primeira opção não nos permite, sem modificações manuais adicionais do arquivo .json, definir algumas propriedades do pacote que são importantes para nós, por exemplo, tags, licença ou URL do repositório, além de não nos permitir definir um ícone para o projeto que será visível no gerenciador de pacotes.
Na segunda variante, duplicamos algumas propriedades do pacote, que, no entanto, podem ser obtidas automaticamente do Visual Studio.
Portanto, seguiremos o caminho 1.5 e criaremos um arquivo com a extensão .nuspec na raiz do projeto (o nome não importa, existe apenas um arquivo), que conterá as informações que não podem ser obtidas em .csproj e combinará essas duas fontes de dados.


 <?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>

Como você pode ver, a estrutura do .nuspec é bastante óbvia. Se você estiver relutante em mexer com o XML, poderá criá-lo através do editor visual NuGet Package Manager e salvá-lo na pasta do projeto para uso futuro. Variáveis ​​como $copyright são obtidas das informações contidas no arquivo .dll, ou seja, do Visual Studio.
Agora queremos usar nosso .nuspec para que, a cada build, obtenhamos um novo pacote. Para fazer isso, vamos para Propriedades e para a guia Build Events.
Escreva palavras mágicas em uma linha de comando do evento Pós-compilação

 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\"

que, traduzido para o russo, significa


  1. Exclua pacotes antigos da pasta em que a compilação é criada
  2. Crie um novo pacote usando os arquivos .csproj e .nuspec
  3. Coloque-o na pasta C:\Program Files (x86)\UiPath\Studio\Packages\

O que é esta pasta? Este é o repositório de pacotes local usado pelo UiPath Studio. Assim que um novo pacote aparecer, ele estará automaticamente disponível através do gerenciador de pacotes e será possível adicioná-lo aos processos de robotização.


Janela Gerenciador de Pacotes do UiPath Studio


NB O caminho para o repositório local pode ser alterado através das configurações do UiPath Studio, para que seja conveniente copiar arquivos para lá, se houver um problema com as permissões.

Tela do UiPath Studio com a ação criada e suas configurações


Isso é tudo, na verdade, parabéns!


Nota: O próprio smart Studio criou uma categoria para a nossa ação, usando pontos como níveis de aninhamento, e coloque espaços na frente das letras maiúsculas no nome da ação.

A próxima parte do artigo será sobre "beleza": sobre como criar uma interface visual para uma ação, atribuir um ícone e localizar textos.


Sério


Atributos


Para que nossa ação funcione, a primeira parte é suficiente. Mas quero que possamos escolher uma categoria, mostrar dicas etc.
Para isso, precisamos de atributos. Existem atributos adequados para a ação em si e para seus parâmetros:


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

E há aqueles que são apenas parâmetros necessários:


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

Localização


Infelizmente, há uma sutileza com atributos: na versão russa do UiPath Studio, os nomes das categorias de ação e as categorias de suas propriedades também são traduzidos. Dessa forma, se definirmos o atributo [Category("Input")] para o parâmetro de entrada, ele será exibido corretamente na versão em inglês, mas na versão em russo cairá em sua própria categoria de entrada separada, e não na categoria de entrada padrão. O mesmo vale para ações: na versão russa, a Integração de aplicativos se torna Integração de aplicativos .
Portanto, precisamos mover as constantes de texto para recursos dependentes do idioma e usá-las a partir daí.
Para fazer isso, crie um arquivo mágico Localization.cs contendo funções para localizar atributos


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; } } } }

Ele nos permitirá substituir o design


 [Category("Name")

em


 [LocalizedCategory(nameof(Resources.CategoryName))]

Para que esse mecanismo funcione, precisamos:


  1. Crie arquivos de recursos para os idiomas que vamos traduzir, no nosso caso, Resources.resx e Resources.ru.resx na pasta Resources ( Adicionar -> Novo Item -> Arquivo de Recursos ). Verifique se o valor do Access Modifier para os recursos está em Public .
  2. Adicionar ao arquivo de ação de classe
     using IlyaK.UiPath.Activities.TutorialForHabr.Properties; //     + .Properties

  3. E defina a classe e todos os parâmetros com os atributos apropriados


     [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. Para que a biblioteca com recursos russos se enquadre no pacote NuGet, você precisa adicionar outra linha ao grupo de arquivos no arquivo .nuspec
     <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>

O designer


Para tornar nossa ação bonita no processo e permitir que os usuários insiram dados sem rastrear as propriedades, precisamos adicionar uma interface do usuário. Isso é feito por meio de um arquivo XAML, que, com a ajuda do Visual Studio, pode ser editado em uma interface especial, mas parte ainda precisará ser corrigida manualmente. Vou dar um modelo para você começar e, em seguida , vale a pena examinar a documentação da Microsoft .


  • Coloque o ícone para a ação na pasta Resources . Nas propriedades da Ação de Compilação configuradas como Recurso (não Recurso Incorporado )
  • Crie um novo Activity Designer ( Adicionar -> Novo Item -> Activity Designer ) na pasta Designer e chame-o de 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>

É assim que definimos o rótulo localizado:


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

, e este é o campo de entrada. ExpressionType define o tipo de campo, HintText - uma dica (texto cinza), Expression associa o valor do campo à nossa ação


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

Nota: Observe a tag BitmapImage no final do arquivo. Então, definimos a imagem para o ícone com um link para o arquivo de recurso. Essa é uma funcionalidade muito frágil e, às vezes, você precisa mexer nela.

de acordo com os resultados, deve ficar assim:


tela de designer de ação


  • Crie a classe DesignerMetata na pasta Atividades

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()); } } }

  • Execute a compilação
  • E atualize o pacote no UiPath Studio.
    Nota: Para que isso funcione, é necessário que a versão do novo pacote seja diferente da versão anterior. A maneira mais fácil de fazer isso é com algum plug-in do Visual Studio, como o suplemento Build Version Increment . Ou atualize a versão manualmente.

Aqui está a visualização final de nossa ação, com um ícone e campos de entrada:
ação finalizada


Conclusão


Espero ter conseguido mostrar que a criação de ações totalmente emolduradas para o UiPath não é tão longa. Eu realmente gostaria que este artigo fosse útil para você e sirva como um bom começo para escrever atividades novas e maravilhosas para o UiPath. E quando você o cria - não esqueça de publicá-lo no UiPath Go!


Materiais adicionais


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

More articles:


All Articles