Escrever o código da atividade

Escreva o código para uma atividade personalizada da UiPath seguindo um exemplo de Calculadora do repositório UiPath.Examples.Activities.

Para demonstrar a gravação de código de atividades, este exemplo recria uma atividade Calculator simples da solução UiPath.Examples.Activities no GitHub. A atividade:

• Aceita dois números e uma operação (adicionar, subtrair, multiplicar ou dividir) como entrada
• Retorna o resultado da operação selecionada

O código da atividade consiste em duas partes:

1. A lógica da atividade
2. O design da atividade

Lógica da atividade

Comece em UiPath.Activities.Template e renomeie a solução mais todos os arquivos e referências relacionados para UiPath.Examples.Activities.

1. Renomeie o arquivo que contém a lógica da atividade de ActivityTemplate.cs para Calculator.cs.
2. Atualize as referências e o namespace da seguinte forma:

   using System.Activities;
   using System.Diagnostics;
   using UiPath.Examples.Activities.Helpers;
   
   namespace UiPath.Examples.Activities
   {
   }
   

3. Declare os argumentos de entrada — dois números (FirstNumber e SecondNumber como int) e a operação a ser realizada (SelectedOperation como enum, com um valor padrão opcional definido como Multiply). Marque todos os três argumentos como necessário usando o atributo [RequiredArgument] . O valor retornado é usado para definir o valor do argumento Result :

       public class Calculator : CodeActivity<int> // This base class exposes an OutArgument named Result
       {
           [RequiredArgument]
           public InArgument<int> FirstNumber { get; set; } //InArgument allows a varriable to be set from the workflow
   
           [RequiredArgument]
           public InArgument<int> SecondNumber { get; set; }
   
           [RequiredArgument]
           public Operation SelectedOperation { get; set; } = Operation.Multiply; // default value is optional
   
           /*
            * The returned value will be used to set the value of the Result argument
            */
       }
   

4. Inicie a parte de execução, adicione registro, obtenha os valores dos números do contexto do fluxo de trabalho e adicione lógica para lidar com o cenário de uma divisão por zero:

    protected override int Execute(CodeActivityContext context)
           {
               // This is how you can log messages from your activity. logs are sent to the Robot which will forward them to Orchestrator
               context.GetExecutorRuntime().LogMessage(new Robot.Activities.Api.LogMessage()
               {
                   EventType = TraceEventType.Information,
                   Message = "Executing Calculator activity"
               });
   
               var firstNumber = FirstNumber.Get(context); //get the value from the workflow context (remember, this can be a variable)
               var secondNumber = SecondNumber.Get(context);
   
               if (secondNumber == 0 && SelectedOperation == Operation.Divide)
               {
                   throw new DivideByZeroException("Second number should not be zero when the selected operation is divide");
               }
   
               return ExecuteInternal(firstNumber, secondNumber);
           }
   

5. Adicione os cálculos a serem executados para cada operação selecionada:

           public int ExecuteInternal(int firstNumber, int secondNumber)
           {
               return SelectedOperation switch
               {
                   Operation.Add => firstNumber + secondNumber,
                   Operation.Subtract => firstNumber - secondNumber,
                   Operation.Multiply => firstNumber * secondNumber,
                   Operation.Divide => firstNumber / secondNumber,
                   _ => throw new NotSupportedException("Operation not supported"),
               };
           }
   

6. Defina as operações:

    public enum Operation
       {
           Add,
           Subtract,
           Multiply,
           Divide
       }
   

Design da atividade

As entradas disponíveis em uma atividade são determinadas pelos tipos de dados das propriedades. Na atividade de exemplo Calculadora:

• O tipo de dados int dos resultados das propriedades FirstNumber e SecondNumber em campos de entrada do editor de números para essas propriedades.
• Para a propriedade Operation , que tem o tipo de dados enum , um menu suspenso está disponível na atividade.

Esses tipos de dados influenciam diretamente como os usuários interagem com as entradas da atividade.

Os rótulos e dicas de ferramentas das propriedades podem ser definidos no arquivo Resources.resx .

A tabela a seguir descreve as propriedades mais comuns disponíveis para cada propriedade de atividade:

Propriedade	Description
NomeDeExibição	O rótulo da propriedade.
Dica de ferramenta	O texto a ser exibido ao passar o mouse sobre a propriedade
É Necessário1	Se a propriedade é necessária. As propriedades obrigatórias também devem ser marcadas na atividade usando o atributo [RequiredArgument] .
ÉPrincipal2	Se a propriedade deve estar sempre visível na categoria principal da atividade. Se definida como false, a propriedade aparece em um menu Mostrar opções avançadas que é recolhido por padrão.
ÍndiceDeOrdem	A ordem de exibição da propriedade.

¹ Não disponível para propriedades de saída, que nunca são obrigatórias.

² Por convenção, as propriedades de saída são colocadas no final da atividade em opções avançadas.

Criação do design para a atividade Calculadora

1. Renomeie o arquivo ActivityTemplateViewModel.cs para CalculatorViewModel.cs, e adicione a ele o código para a interface do usuário da atividade.

2. Atualize as referências e o namespace da seguinte forma:

   using System.Activities.DesignViewModels;
   using System.Diagnostics;
   
   namespace UiPath.Examples.Activities.ViewModels
   {
   }
   

3. Declare as propriedades de entrada. A propriedade result vem da classe base da atividade. Os nomes e os argumentos de tipo devem corresponder aos da atividade:

   public class CalculatorViewModel : DesignPropertiesViewModel
       {
           /*
            * Properties names must match the names and generic type arguments of the properties in the activity
            * Use DesignInArgument for properties that accept a variable
            */
           public DesignInArgument<int> FirstNumber { get; set; }
           public DesignInArgument<int> SecondNumber { get; set; }
           /*
            * Use DesignProperty for properties that accept a constant value                
            */
           public DesignProperty<Operation> SelectedOperation { get; set; }
            /*
            * The result property comes from the activity's base class
            */
           public DesignOutArgument<int> Result { get; set; }
           
           public CalculatorViewModel(IDesignServices services) : base(services)
           {
           }
       }
   

4. Adicione o código para o design da atividade. Opcionalmente, para depurar a inicialização ViewModel , adicione um ponto de interrupção descomentar a linha que contém Debugger.Break();.

   O fragmento de código a seguir inicializa as propriedades do ViewModel, adiciona uma chamada PersistValuesChangedDuringInit() que é obrigatória quando você altera os valores da propriedade durante a inicialização e define as propriedades de entrada e saída da atividade:

    protected override void InitializeModel()
           {
              //Debugger.Break(); 
               /*
                * The base call will initialize the properties of the view model with the values from the xaml or with the default values from the activity
                */
               base.InitializeModel();
   
               PersistValuesChangedDuringInit(); // just for heads-up here; it's a mandatory call only when you change the values of properties during initialization
   
               var orderIndex = 0;
   
               FirstNumber.DisplayName = Resources.Calculator_FirstNumber_DisplayName;
               FirstNumber.Tooltip = Resources.Calculator_FirstNumber_Tooltip;
               /*
                * Required fields will automatically raise validation errors when empty.
                * Unless you do custom validation, required activity properties should be marked as such both in the view model and in the activity:
                *   -> in the view model use the IsRequired property
                *   -> in the activity use the [RequiredArgument] attribute.
                */
               FirstNumber.IsRequired = true;
   
               FirstNumber.IsPrincipal = true; // specifies if it belongs to the main category (which cannot be collapsed)
               FirstNumber.OrderIndex = orderIndex++; // indicates the order in which the fields appear in the designer (i.e. the line number);
   
               SecondNumber.DisplayName = Resources.Calculator_SecondNumber_DisplayName;
               SecondNumber.Tooltip = Resources.Calculator_SecondNumber_Tooltip;
               SecondNumber.IsRequired = true;
               SecondNumber.IsPrincipal = true;
               SecondNumber.OrderIndex = orderIndex++;
   
               SelectedOperation.DisplayName = Resources.Calculator_SelectedOperation_DisplayName;
               SelectedOperation.Tooltip = Resources.Calculator_SelectedOperation_Tooltip;
               SelectedOperation.IsRequired = true;
               SelectedOperation.IsPrincipal = true;
               SelectedOperation.OrderIndex = orderIndex++;
   
               /*
                * Output properties are never mandatory.
                * By convention, they are not principal and they are placed at the end of the activity.
                */
               Result.DisplayName = Resources.Calculator_Result_DisplayName;
               Result.Tooltip = Resources.Calculator_Result_Tooltip;
               Result.OrderIndex = orderIndex;
           }
   

5. Adicione os valores de string para os rótulos e dicas de ferramenta no arquivo Resources.resx . Para fins de localização, você deve usar comentários específicos para o nome da atividade (Activity name) e a descrição da atividade (Activity description). Para outras strings, é recomendável adicionar comentários.

   

A imagem a seguir mostra a configuração da atividade conforme exibida no UiPath Studio:

1 – Rótulos (nomes de exibição) das três propriedades de entrada.

2 - Dica de ferramenta para a propriedade FirstNumber .