Criar pacotes de atividades

Como a plataforma do UiPath é construída na estrutura .NET, todas as atividades assumem a forma de um pacote Nuget (que é o pacote .nupkg .reg. que você obtém ao baixar uma atividade diretamente do Go! para o Marketplace ou dos feeds no gerenciador de pacotes do UiPath Studio). Há 4 tipos de arquivos necessários para agrupar seus arquivos em um único pacote Nuget:

Arquivos do AssemblyInfo

Sempre que você cria um projeto dentro do Visual Studio, o Microsoft Build Engine (também conhecido como MSBuild) transforma o código desse projeto em uma DLL, uma biblioteca que pode ser usada por outros aplicativos do Windows. Os metadados para essa biblioteca vêm de três arquivos AssemblyInfo , armazenados na seção Propriedades do seu projeto, que fornecem informações para diferentes níveis de um conjunto de atividades. Vamos dar uma olhada em cada um:

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 contém os metadados exclusivos desse projeto específico (por exemplo, MyCompany.MyProduct).

• O AssemblyTitle fornece um nome amigável para sua DLL. Para simplificar, deve corresponder ao nome do projeto.

• AssemblyDescription é um breve resumo da natureza e finalidade do assembly.

  Existem vários outros atributos, como cultura ou número da versão, que podem ser incluídos. Para obter uma lista completa, consulte a documentação oficial da Microsoft.

• ComVisível e Guid são atributos padrão usados por aplicativos que fazem referência à biblioteca final deste projeto. Eles permanecem intocados para a maioria das atividades, mas você pode ler mais sobre seus efeitos aqui.

2. MyCompany.MyProductAssemblyInfo.cs

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

O próximo arquivo de Assembly, <your activity name>AssemblyInfo.cs, contém os metadados que são exclusivos para o conjunto de atividades como um todo, mas são compartilhados entre todos os projetos; neste caso, apenas a versão da atividade. Observe que a versão é diferente para cada configuração do Visual Studio:

• Depurar: se o Visual Studio estiver no modo de depuração, a atividade será criada com um número de versão 1.0.*, o que significa que as versões principal e secundária estão definidas (1.0) e os incrementos da versão de patch em cada compilação. Isso é útil ao fazer alterações frequentes no mesmo código, pois cada pacote subsequente será criado com uma nova versão, tornando-o facilmente reconhecível.

• Versão: se o Visual Studio estiver no modo de versão, o número da versão será definido (por exemplo, 1.0.0). Isso oferece controle completo no momento de lançar oficialmente um pacote.

  
  

  

  
  

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")]

A GlobalAssemblyInfo.cs contém os metadados compartilhados entre todos os conjuntos de atividades que você produzir. Os pacotes UiPath.GSuite.Activities e UiPath.MicrosoftOffice365.Activities , por exemplo, foram criados pela mesma empresa (UiPath), visam o mesmo produto (UiPath Studio) e têm as mesmas informações de direitos autorais, marca registrada e idioma. Portanto, eles usaram o mesmo arquivo GlobalAssemblyInfo.cs para evitar duplicações desnecessárias.

Nuspec

Depois que todos os seus projetos forem compilados em DLLs, essas bibliotecas serão agrupadas em um pacote Nuget que poderá ser usado no UiPath Studio. Os metadados desse pacote vêm do arquivo nuspec dentro de seu projeto de Design.

Você pode ver a lista completa de elementos de metadados disponíveis por meio do nuspec aqui, mas dê uma olhada no exemplo básico abaixo primeiro. Esses elementos correspondem aos campos exibidos no gerenciador de pacotes do UiPath Studio e permitem que os usuários encontrem e diferenciem seu conjunto de atividades.

Observe que alguns dos elementos, como id e versão, contêm tags no formato $element$. Elas estão extraindo seus valores das tags correspondentes nos arquivos de AssemblyInfo para evitar a duplicação de informações.

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

Observação: se você estiver familiarizado com o Visual Studio, deve saber que ele é, na verdade, capaz de criar pacotes Nuget por conta própria usando apenas os arquivos AssemblyInfo e o MSBuild. Então, por que usar um arquivo nuspec extra? Determinadas propriedades de metadados, como os arquivos de Proprietário do pacote e de Localização , estão disponíveis apenas em um nuspec, e é por isso que queremos mantê-lo.

Metadados do Designer

Após suas atividades serem criadas e seus designers (elementos de interface gráfica) construídos, eles devem ser vinculados e registrados no repositório de metadados para serem exibidos no painel Atividades do UiPath Studio. O código abaixo cria duas atividades (Escopo pai e Atividade filho), registrando as seguintes informações em nome de cada uma:

• Categoria: a seção do painel de atividades na qual essas atividades serão exibidas. Por padrão, isso é definido como MyCompany > MyProduct e pode ser alterado modificando o atributo Categoria em Resources.resx. Veja como a linha 12 vincula uma classe do seu projeto de atividade à categoria especificada na linha 10.
• Designer: a interface gráfica para essa atividade. Veja como a linha 13 vincula uma classe do seu projeto de atividade a uma classe do seu projeto de design.

• Documentação: documentos online para a atividade. Selecione qualquer atividade em um dos fluxos de trabalho da UiPath, pressione F1 e a documentação de ajuda para essa atividade será aberta no navegador padrão. O URL para esta documentação é especificado aqui, como na linha 14 (go.uipath.com é usado como espaço reservado).

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

  
  

  

  
  

Criar o conjunto de atividades

Quando os arquivos mencionados acima estão completos, é fácil criar o conjunto de atividades. No Explorador de Soluções, clique com o botão direito do mouse na sua solução e selecione Recompilar Solução.

O painel de saída indicará que todos os três projetos foram criados com sucesso e fornecerá o caminho para seu arquivo nupkg incluído.

Observação: para criar seu pacote de atividades, você também pode ter clicado com o botão direito do mouse e "Reconstruído" na pasta MyCompany.MyProduct ou no projeto MyCompany.MyProduct.Activities.Design . Por que isso? Consulte a próxima seção sobre scripts pós-compilação.

Scripts pós-compilação

Navegue até Propriedades > Eventos de Compilação do seu projeto de Criação e você encontrará um script de pós-compilação, que será executado imediatamente após todos os projetos serem criados.

A primeira linha desse script exclui quaisquer versões mais antigas e obsoletas do pacote que existem no diretório de saída para evitar desordem.

A segunda linha usa a ferramenta de Linha de Comando NuGet (nuget.exe) para combinar os DLLs dos três projetos em um pacote NuGet que pode ser lido pelo 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)