Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
O Service Manager automatiza vários processos de tecnologia da informação (TI). Para o processo de Gerenciamento de Incidentes, por exemplo, o Service Manager inclui várias etapas automatizadas, como notificações automatizadas aos usuários quando incidentes são criados ou resolvidos e roteamento automático de incidentes para várias filas, com base na categorização. Essa automação é implementada usando fluxos de trabalho definidos para as várias soluções e usa os recursos do Windows Workflow Foundation (WF) para descrever, executar e controlar as operações automatizadas.
Clientes e parceiros podem estender a automação incluída definindo novos fluxos de trabalho e adicionando-os a um processo. Os fluxos de trabalho podem ser definidos para ocorrer em um cronograma fixo ou em uma condição especificada que ocorra no banco de dados, por exemplo, quando um incidente é criado ou quando ele muda para um estado especificado, como Ative ou Resolved.
A Ferramenta de Criação do Service Manager fornece um método fácil de usar para criar novos fluxos de trabalho. É fornecida uma biblioteca de diferentes atividades de fluxo de trabalho, como a criação ou atualização de um incidente, e um editor gráfico de arrastar e soltar que pode ser usado para organizar essas atividades de fluxo de trabalho em uma sequência. Em seguida, a Ferramenta de Criação compila o novo fluxo de trabalho em um conjunto de definições, código e conteúdo do pacote de gerenciamento. Quando essas informações são importadas para o Service Manager, elas integram o novo fluxo de trabalho na solução especificada.
Compreender o que está a acontecer nos bastidores da Ferramenta de Autoria pode beneficiar os utilizadores mais avançados. Primeiro, os clientes e parceiros podem usar essas informações para estender a biblioteca de atividades do fluxo de trabalho no Service Manager com atividades de fluxo de trabalho que se aplicam aos seus processos específicos. Em segundo lugar, os desenvolvedores podem usar essas informações para criar fluxos de trabalho personalizados ou avançados que são compatíveis com o Service Manager usando sua ferramenta de desenvolvimento de escolha, como o sistema de desenvolvimento Microsoft Visual Studio.
Atividades de fluxo de trabalho e a classe WorkflowActivityBase
Os fluxos de trabalho do Service Manager usam atividades do WF. Para funcionar sem problemas com a Authoring Tool, essas atividades derivam da classe base WorkflowActivityBase, que pertence ao namespace Microsoft.EnterpriseManagement.Workflow.Common. A classe base WorkflowActivityBase apresenta propriedades e métodos que não estão disponíveis na classe base genérica Activity para atividades WF. Para obter mais informações sobre como definir atividades do WF usando a classe base genérica Activity, consulte Activity Class.
Benefícios do uso da classe WorkflowActivityBase
Os utilizadores podem importar atividades do WF da biblioteca de atividades do Visual Studio e trabalhar com essas atividades no painel de Criação da Ferramenta de Autor Authoring. No entanto, essas atividades se comportam da mesma maneira que no ambiente de Design do Visual Studio. Eles não têm as personalizações que são incorporadas na biblioteca de atividades do Service Manager.
Observação
Nem todas as atividades do Visual Studio WF foram testadas quanto à compatibilidade com a ferramenta de criação e algumas atividades do Visual Studio WF podem não ser executadas corretamente na ferramenta de criação.
A tabela a seguir lista as diferenças de comportamento entre as atividades WF baseadas na classe base WorkflowActivityBase e as atividades WF baseadas na classe base genérica Activity.
| Cenário | Atividade da ferramenta de criação WF (WorkflowActivityBase classe base) | Atividade WF do Visual Studio (classe base de atividade) |
|---|---|---|
| O usuário vincula as propriedades de atividade (às propriedades do objeto do Service Manager ou às propriedades de outras atividades). | Chama a propriedade Bind para o diálogo personalizado para os utilizadores do Service Manager. | Chama a propriedade de ligação para a caixa de diálogo destinada aos desenvolvedores. |
| O utilizador adiciona a atividade a uma atividade de For-Each Loop. | Adiciona as propriedades Propertytobind (o índice de loop) e CurrentItem, que são necessárias para participar de operações específicas de loop (CurrentItem é uma propriedade interna). | Comporta-se da mesma maneira para cada iteração do loop e não interage com a propriedade que indexa o loop. |
Importante
Devido às personalizações necessárias para o designer de fluxo de trabalho da Ferramenta de Criação, as atividades baseadas na classe WorkFlowActivityBase não funcionam como esperado no ambiente de design de fluxo de trabalho do Visual Studio.
Os usuários podem criar atividades WF personalizadas no Visual Studio para uso na ferramenta de criação. No entanto, para aproveitar o comportamento personalizado durante o tempo de design da Ferramenta de Criação, as atividades personalizadas devem ser baseadas na classe WorkflowActivityBase, em vez da classe Activity.
Atividades de fluxo de trabalho e atividades automatizadas do Service Manager
As atividades do WF podem interagir com um tipo diferente de atividade: as atividades do Service Manager, utilizadas nos itens de trabalho do Service Manager. Itens de trabalho são um dos principais tipos de objetos que o Service Manager usa. Os itens de trabalho rastreiam unidades de trabalho, como Incidentes, Solicitações de Serviço, Solicitações de Alteraçãoe outras unidades de trabalho. A maioria dos itens de trabalho compreende uma ou mais atividades do Service Manager. Por exemplo, uma Solicitação de Alteração normalmente inclui pelo menos duas atividades: uma atividade de Revisão e uma atividade de Execução de Alterações. O item de trabalho normalmente executa essas atividades por ordem.
Quando um item de trabalho é criado, a primeira atividade do Service Manager torna-se ativa e permanece ativa enquanto o Service Manager (ou o usuário) realiza qualquer trabalho que a atividade represente. Quando esse trabalho termina, o Service Manager marca a primeira atividade como Concluído e ativa a próxima atividade na sequência. Quando a atividade final na sequência é marcada como Concluído, o Service Manager marca todo o item de trabalho como Concluído.
Algumas atividades do Service Manager podem ser executadas manualmente, como a atividade de revisão de um pedido de mudança . Outras atividades do Service Manager podem ser automatizadas, como uma atividade que envia um e-mail para um usuário. A atividade Execução de Alterações de uma Solicitação de Alteração pode ser automatizada. O Service Manager usa fluxos de trabalho do WF para automatizar as atividades do Service Manager.
Exemplo: A atividade Definir Status da Atividade como Concluída
Este exemplo de uma atividade de fluxo de trabalho de WF no Service Manager utiliza a atividade de WF Configurar Estado da Atividade como Concluído. Essa atividade do WF normalmente representa a última etapa em um fluxo de trabalho que implementa uma atividade automatizada do Service Manager e define o status dessa atividade como Concluído. Definir esse status aciona o sistema para mover para a próxima atividade no item de trabalho, e esse processo se repete até que a última atividade no item de trabalho seja concluída.
A atividade Definir Estado da Atividade como Concluído usa como entrada ID de Atividade, que identifica a atividade do Service Manager em que atuar. Depois, a atividade WF liga-se ao servidor de gestão do Service Manager, recupera a atividade especificada do banco de dados do Service Manager, define o seu estado como Concluídoe salva-a novamente no banco de dados. A maioria dos exemplos de código incluídos neste exemplo vem do arquivo SetActivityStatusToCompleted.cs, um arquivo subjacente que descreve a atividade Definir Status da Atividade como Concluída.
Inicializar a atividade WF de exemplo
A primeira seção do arquivo SetActivityStatusToCompleted.cs contém as instruções de declaração e inicialização. Esta atividade é baseada na classe WorkflowActivityBase e utiliza a classe de validador SetActivityStatusToCompletedValidator e a classe de designer WorkflowActivityBaseDesigner.
A classe WorkflowActivityBaseDesigner contém as personalizações que são descritas na seção anterior, Benefícios do Uso da Classe WorkflowActivityBase. Você pode estender e personalizar ainda mais essa classe.
A primeira seção da definição de atividade para esta atividade de exemplo inclui o seguinte código:
namespace Microsoft.ServiceManager.WorkflowAuthoring.ActivityLibrary
{
// ---------------------------------------------------------------------
/// <summary>
/// Activity to set an activity's status to complete
/// </summary>
// ---------------------------------------------------------------------
[ToolboxItem(typeof(ActivityToolboxItem))]
[ActivityValidator(typeof(Validators.SetActivityStatusToCompletedValidator))]
[Designer(typeof(WorkflowActivityBaseDesigner))]
public sealed partial class SetActivityStatusToCompleted : WorkflowActivityBase
{
Propriedades de entrada do exemplo de atividade WF
O código declara uma propriedade, ActivityId, como uma propriedade de dependência. Isso significa que essa propriedade pode ser vinculada a parâmetros definidos no nível do fluxo de trabalho. Neste caso, o ID da atividade do Gestor de Serviços é passado para o fluxo de trabalho como um parâmetro de fluxo de trabalho e flui para essa atividade como uma entrada.
// --------------------------------------------------------------------------------
/// <summary>
/// Dependency Property for ActivityId property
/// </summary>
// --------------------------------------------------------------------------------
public static DependencyProperty ActivityIdProperty =
DependencyProperty.Register("ActivityId", typeof(String), typeof(SetActivityStatusToCompleted));
// --------------------------------------------------------------------------------
/// <summary>
/// Activity ID
/// </summary>
// --------------------------------------------------------------------------------
[Browsable(true)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
public string ActivityId
{
get
{
return (string)this.GetValue(ActivityIdProperty);
}
set
{
this.SetValue(ActivityIdProperty, value);
}
}
Comportamento de execução no exemplo de atividade WF
O método Execute realiza efetivamente o trabalho desta atividade WF. Dentro do escopo do método Execute, a atividade WF faz o seguinte:
Deteta-se se está a operar dentro de uma atividade For-Each loop, e, em caso afirmativo, define as propriedades de atividade WF apropriadas.
Conecta-se ao servidor de gerenciamento do Service Manager especificado e cria um objeto EnterpriseManagementGroup.
Usa a propriedade ActivityId para obter a atividade identificada do Service Manager do banco de dados.
Localiza a definição de classe da atividade do Service Manager, obtém a propriedade Status da atividade recuperada do Service Manager e define a propriedade como o valor da lista de enumeração Concluído.
Confirma as alterações na atividade do Service Manager.
Usa o método TrackData (parte da infraestrutura do WF) para registrar informações de controle sobre a execução e o status da atividade do WF.
// --------------------------------------------------------------------------------
/// <summary>
/// The execute method will have the implementation to set the activity status to complete.
/// </summary>
// --------------------------------------------------------------------------------
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
try
{
// Initialize the current item if the activity contained within the For-Each loop
base.Execute(executionContext);
// Validate Parameters
if (String.IsNullOrEmpty(ActivityId))
{
throw new ArgumentNullException("ActivityId");
}
string SMServer = "localhost";
Guid TaskGuid = new Guid(ActivityId);
EnterpriseManagementGroup _mg = new EnterpriseManagementGroup(SMServer);
EnterpriseManagementObject Activity = _mg.EntityObjects.GetObject
<EnterpriseManagementObject>(TaskGuid, ObjectQueryOptions.Default);
ManagementPack SystemMP = _mg.ManagementPacks.GetManagementPack(
SystemManagementPack.System);
ManagementPack ActivityMP = _mg.ManagementPacks.GetManagementPack(
Resources.ActivityManagementMP, SystemMP.KeyToken, SystemMP.Version);
ManagementPackClass activityClass = _mg.EntityTypes.GetClass(
Resources.WorkItemActivityClass, ActivityMP);
ManagementPackProperty status = activityClass.PropertyCollection["Status"];
ManagementPackEnumeration Completed =
_mg.EntityTypes.GetEnumeration("ActivityStatusEnum.Completed", ActivityMP);
Activity[status].Value = Completed;
Activity.Commit();
}
catch (ArgumentNullException argNullException)
{
// Log to Tracking Service
TrackData(argNullException.ToString());
throw;
}
catch (EnterpriseManagementException mgmtException)
{
TrackData(mgmtException.ToString());
throw;
}
return ActivityExecutionStatus.Closed;
}
}
}
Comportamento de validação no exemplo de atividade WF
O arquivo SetActivityStatusToCompletedValidator.cs define o comportamento de validação da atividade WF. Esse comportamento define como o designer indica se essa atividade WF está totalmente definida ou se ainda requer uma ou mais entradas a serem definidas. A Ferramenta de Criação indica um erro de validação de forma semelhante à do Visual Studio, usando um ícone de ponto de exclamação vermelho (!) na atividade do fluxo de trabalho no painel de Criação .
namespace Microsoft.ServiceManager.WorkflowAuthoring.ActivityLibrary.Validators
{
// --------------------------------------------------------------------------------
/// <summary>
/// Validator for the SetActivityStatusToCompleted activity
/// </summary>
// --------------------------------------------------------------------------------
internal class SetActivityStatusToCompletedValidator : ActivityValidator
{
// --------------------------------------------------------------------------------
/// <summary>
/// Validator for the SetActivityStatusToCompleted activity
/// </summary>
// --------------------------------------------------------------------------------
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
// Performing default validation
ValidationErrorCollection errorColl = base.Validate(manager, obj);
SetActivityStatusToCompleted setActivityStatusToCompletedObj =
(SetActivityStatusToCompleted)obj;
// Check if validation is happening during compilation of activity and
// not during the hosting of an activity
if (setActivityStatusToCompletedObj.Parent == null)
{
return errorColl;
}
string propertyName = Common.GetPropertyName(setActivityStatusToCompletedObj);
// Add validation error if ActivityId is null or empty
if (setActivityStatusToCompletedObj.ActivityId == null
&&
setActivityStatusToCompletedObj.GetBinding(SetActivityStatusToCompleted.ActivityIdProperty) == null
&&
String.Compare(propertyName, "ActivityId", false, CultureInfo.InvariantCulture) != 0)
{
errorColl.Add(new ValidationError(
Resources.SetActivityStatusToCompleted_ActivityId_DesignTimeValidation, 10, false));
}
return errorColl;
}
}
}
Usar o exemplo de atividade WF em um fluxo de trabalho
A atividade Definir Status da Atividade como Concluída está incluída na janela da Caixa de Ferramentas de Atividades padrão da Ferramenta de Criação. Para mais informações sobre como adicionar atividades personalizadas ao painel Activities Toolbox, consulte Como instalar uma montagem personalizada de atividade.
Você pode usar o painel de criação da ferramenta de criação para criar fluxos de trabalho de maneira semelhante ao uso da interface de design de fluxo de trabalho do Visual Studio. No entanto, a Ferramenta de Autoria oferece os seguintes benefícios:
Usuários sem habilidades de desenvolvimento podem criar fluxos de trabalho; eles não precisam trabalhar com código diretamente.
Quando um usuário salva um fluxo de trabalho na ferramenta de criação, a ferramenta gera o código Visual C# e XOML correspondente e o compila em um arquivo .dll. A ferramenta também integra o fluxo de trabalho com um pacote de gerenciamento que pode interagir diretamente com o Service Manager.
Código Visual C# para o fluxo de trabalho
O exemplo a seguir mostra o código Visual C# que a ferramenta de criação gera para um fluxo de trabalho de exemplo que usa a atividade Definir status da atividade como Concluída. Este código declara um fluxo de trabalho sequencial simples, SetActivityStatusToCompleteWF que tem um parâmetro de fluxo de trabalho, a propriedade de dependência ActivityId. O valor de ActivityID é determinado pelas definições do pacote de gerenciamento mostradas posteriormente neste exemplo. Quando o fluxo de trabalho é executado, o Service Manager identifica o valor e o passa para o fluxo de trabalho.
namespace WorkflowAuthoring
{
using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Workflow.ComponentModel.Design;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Serialization;
using System.Workflow.ComponentModel.Compiler;
using System.Drawing;
using System.Collections;
using System.Workflow.Activities;
using System.Workflow.Runtime;
public partial class SetActivityStatusToCompleteWF : System.Workflow.Activities.SequentialWorkflowActivity
{
public static DependencyProperty ActivityIdProperty = DependencyProperty.Register("ActivityId", typeof(string), typeof(SetActivityStatusToCompleteWF));
[System.ComponentModel.DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Visible)]
[System.ComponentModel.BrowsableAttribute(true)]
[System.ComponentModel.CategoryAttribute("Misc")]
public string ActivityId
{
get
{
return ((string)(this.GetValue(ActivityIdProperty)));
}
set
{
this.SetValue(ActivityIdProperty, value);
}
}
}
}
Código XOML para o fluxo de trabalho
O WF usa o formato XOML para algumas das definições de fluxo de trabalho. Para o fluxo de trabalho de exemplo, a Ferramenta de Criação cria o arquivo SetActivityStatusToCompleteWF.xoml com o seguinte conteúdo:
<SequentialWorkflowActivity x:Class="WorkflowAuthoring.SetActivityStatusToCompleteWF" x:Name="SetActivityStatusToCompleteWF" xmlns:ns0="clr-namespace:Microsoft.ServiceManager.WorkflowAuthoring.ActivityLibrary;Assembly=Microsoft.ServiceManager.WorkflowAuthoring.ActivityLibrary, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml" xmlns="https://schemas.microsoft.com/winfx/2006/xaml/workflow">
<ns0:SetActivityStatusToCompleted ActivityId="{ActivityBind SetActivityStatusToCompleteWF,Path=ActivityId}" x:Name="setActivityStatusToCompleted1" PropertyToBind="{x:Null}" />
</SequentialWorkflowActivity>
SetActivityStatusToCompleteWF.xoml declara que o fluxo de trabalho, SetActivityStatusToCompleteWF, executa uma atividade de fluxo de trabalho, Definir Estado da Atividade como Concluído. Essa atividade tem um parâmetro de entrada, ActivityId, que obtém seu valor da propriedade ActivityId do fluxo de trabalho.
Declarar o fluxo de trabalho e sua condição de gatilho em um pacote de gerenciamento
O Service Manager não pode usar um fluxo de trabalho isolado .dll arquivo; O fluxo de trabalho deve ser integrado a um pacote de gerenciamento. O pacote de gerenciamento define quando o fluxo de trabalho deve ser executado e quais valores de entrada usar. Ao mesmo tempo que gera o código de fluxo de trabalho e compila o arquivo .dll de fluxo de trabalho, a Ferramenta de Criação adiciona as informações relacionadas ao fluxo de trabalho a um pacote de gerenciamento.
O fluxo de trabalho de exemplo, SetActivityStatusToCompleteWF, está associado a um pacote de gerenciamento de exemplo, chamado Woodgrove.AutomatedActivity.AddComputerToGroupMP.xml. Este pacote de gerenciamento estende o processo de de Gerenciamento de Alterações com uma nova atividade automatizada do Service Manager. Quando a nova atividade se torna ativa durante uma operação de gestão de mudanças, ela dispara o fluxo de trabalho SetActivityStatusToCompleteWF.
O pacote de gerenciamento define o gatilho do fluxo de trabalho (quando a nova atividade do Service Manager muda de estado) e define o valor a ser usado para a propriedade ActivityId (o identificador exclusivo da nova atividade do Service Manager). Quando o fluxo de trabalho é executado, ele altera o status da nova atividade do Service Manager para Concluído. Observe que, em um fluxo de trabalho normal, essa seria a última etapa após alguma outra tarefa executada por outras atividades do WF no fluxo de trabalho.
A seção Monitorização do pacote de gestão contém a definição de regra para o fluxo de trabalho. Por sua vez, a definição de Rule tem duas partes: o elemento DataSource e o elemento WriteAction.
Para o fluxo de trabalho de exemplo, o elemento DataSource contém um elemento Subscription, que especifica que o fluxo de trabalho é executado quando uma instância da classe AddComputerToGroup (uma classe personalizada do Service Manager) muda de estado para Active.
<Monitoring>
<Rules>
<Rule ID="SetActivityToCompleteRule" Enabled="true" Target="SystemCenterLibrary!Microsoft.SystemCenter.SubscriptionWorkflowTarget" ConfirmDelivery="false" Remotable="true" Priority="Normal" DiscardLevel="100">
<Category>Notification</Category>
<DataSources>
<DataSource ID="DS" TypeID="Subscriptions!Microsoft.SystemCenter.CmdbInstanceSubscription.DataSourceModule">
<Subscription>
<InstanceSubscription Type="$MPElement[Name='AddComputerToGroup']$">
<UpdateInstance><Criteria><Expression><SimpleExpression>
<ValueExpression>
<Property State="Post">$Context/Property[Type='Activity!System.WorkItem.Activity']/Status$</Property>
</ValueExpression>
<Operator>Equal</Operator>
<ValueExpression>
<Value>$MPElement[Name='Activity!ActivityStatusEnum.Active']$</Value>
</ValueExpression>
</SimpleExpression></Expression></Criteria></UpdateInstance>
</InstanceSubscription>
<StartWatermark>1</StartWatermark>
<PollingIntervalInSeconds>60</PollingIntervalInSeconds>
<BatchSize>100</BatchSize>
</Subscription>
</DataSource>
</DataSources>
</Rule>
</Rules>
</Monitoring>
O elemento WriteAction (especificamente, Microsoft.EnterpriseManagement.SystemCenter.Subscription.WindowsWorkflowTaskWriteAction) define o que fazer quando a condição de disparo é atendida. Dentro desse elemento, um elemento Subscription identifica o arquivo de assembly do fluxo de trabalho a ser executado (SetActivityStatusToCompleteWF.dll) e a classe no assembly que representa o fluxo de trabalho, WorkflowTypeName.
O elemento Subscription também inclui um elemento WorkflowParameter, que define a propriedade ActivityId e, usando a sintaxe $Data/BaseManagedEntityId$, a vincula ao identificador exclusivo da atividade do Service Manager registrada no elemento DataSource.
O elemento WriteAction também armazena detalhes de configuração opcionais para o fluxo de trabalho, como quantas novas tentativas devem ser executadas se o fluxo de trabalho falhar, com que frequência tentar novamente e o tempo máximo em segundos que um fluxo de trabalho deve ser executado antes de ser desligado.
<WriteActions>
<WriteAction ID="WA" TypeID="Subscriptions!Microsoft.EnterpriseManagement.SystemCenter.Subscription.WindowsWorkflowTaskWriteAction">
<Subscription>
<WindowsWorkflowConfiguration>
<AssemblyName>SetActivityStatusToCompleteWF</AssemblyName>
<WorkflowTypeName>WorkflowAuthoring.SetActivityStatusToCompleteWF</WorkflowTypeName>
<WorkflowParameters>
<WorkflowParameter Name="ActivityId" Type="string">
$Data/BaseManagedEntityId$
</WorkflowParameter>
</WorkflowParameters>
<RetryExceptions></RetryExceptions>
<RetryDelaySeconds>60</RetryDelaySeconds>
<MaximumRunningTimeSeconds>300</MaximumRunningTimeSeconds>
</WindowsWorkflowConfiguration>
</Subscription>
</WriteAction>
</WriteActions>
Importar o pacote de gerenciamento
Para que o fluxo de trabalho seja executado em um determinado servidor de gerenciamento do Service Manager, todos os arquivos relacionados ao fluxo de trabalho devem residir nesse servidor. Esses arquivos incluem o seguinte:
Os ficheiros de compilação de atividades do WF. Se você estiver usando apenas as atividades WF do Service Manager, por padrão, os arquivos apropriados serão instalados. Se estiver a usar atividades personalizadas, consulte Como instalar um assembly de atividade personalizada.
O ficheiro de montagem do fluxo de trabalho, neste caso, SetActivityStatusToCompleteWF.dll. Você deve copiar manualmente esse arquivo para o servidor de gerenciamento do Service Manager.
O arquivo do pacote de gerenciamento, nesse caso, Woodgrove.AutomatedActivity.AddComputerToGroupMP.xml. Você deve copiar manualmente esse arquivo para o servidor de gerenciamento do Service Manager.
Quando todos os arquivos estiverem no lugar, importe o pacote de gerenciamento para o Service Manager. Você pode fazer isso usando a ferramenta de linha de comando mpimport.exe ou o Console do Service Manager. Depois de importar o pacote de gerenciamento, o fluxo de trabalho estará pronto para ser executado sempre que a condição definida como seu gatilho for atendida.