Diretrizes para criar atividades personalizadas na Ferramenta de Criação do Service Manager
O Service Manager automatiza vários processos de TI (tecnologia da informação). Para o processo de Gerenciamento de Incidentes, por exemplo, Service Manager inclui várias etapas automatizadas, como notificações automatizadas para 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 que são definidos para as várias soluções e ela usa os recursos do Windows Workflow Foundation (WF) para descrever, executar e acompanhar 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. Podem ser definidos fluxos de trabalho 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 é alterado para um estado especificado, como Ativo ou Resolvido.
A Ferramenta de Criação do Service Manager fornece um método fácil de usar para criar novos fluxos de trabalho. Ele fornece uma biblioteca de diferentes atividades de fluxo de trabalho, como criar ou atualizar um incidente, e um designer gráfico de arrastar e soltar que você pode usar para organizar essas atividades de fluxo de trabalho em uma sequência de fluxo de trabalho. 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 à solução especificada.
Entender o que está acontecendo nos bastidores da Ferramenta de Autoria pode beneficiar usuários mais avançados. Primeiro, os clientes e parceiros podem usar essas informações para estender a biblioteca de atividades de fluxo de trabalho no Service Manager com atividades de fluxo de trabalho que se aplicam a seus processos específicos. Em segundo lugar, os desenvolvedores podem usar essas informações para criar fluxos de trabalho personalizados ou avançados compatíveis com o Service Manager usando a ferramenta de desenvolvimento de sua 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 Ferramenta de Criação, essas atividades derivam da classe base WorkflowActivityBase, que pertence ao namespace Microsoft.EnterpriseManagement.Workflow.Common . A classe base WorkflowActivityBase introduz propriedades e métodos que não estão disponíveis na classe base genérica Activity para atividades do WF. Para obter mais informações sobre como definir atividades do WF usando a classe base Activity genérica, consulte Classe de atividade.
Benefícios de usar a classe WorkflowActivityBase
Os usuários podem importar atividades do WF da biblioteca de atividades do Visual Studio e podem trabalhar com essas atividades no painel Criação da Ferramenta de Criação. No entanto, essas atividades se comportam da mesma forma que no ambiente do Visual Studio Design. Eles não têm as personalizações que são incorporadas à 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 no comportamento entre atividades do WF que são baseadas na classe base WorkflowActivityBase e atividades do WF que são baseadas na classe base Activity genérica.
| Cenário | Atividade WF da Ferramenta de Criação (classe base WorkflowActivityBase ) | Atividade WF do Visual Studio (classe baseActivity ) |
|---|---|---|
| O usuário associa propriedades de atividade (a propriedades de objeto do Service Manager ou a propriedades de outras atividades). | Chama a propriedade Bind para a caixa de diálogo personalizada para usuários do Service Manager. | Chama a propriedade Bind para a caixa de diálogo destinada a desenvolvedores. |
| O usuário adiciona a atividade a uma atividade For-Each Loop . | Adiciona as propriedades Propertytobind (índice de loop) e CurrentItem, que são necessárias para participar de operações específicas do 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 conforme o esperado no ambiente de design de fluxo de trabalho do Visual Studio.
Os usuários podem criar atividades personalizadas do WF no Visual Studio para uso na Ferramenta de Criação. No entanto, para aproveitar o comportamento de tempo de design personalizado 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 que são usadas pelos itens de trabalho do Service Manager. Os itens de trabalho são um dos principais tipos de objetos que o Service Manager usa. Os itens de trabalho acompanham 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 geralmente inclui pelo menos duas atividades: uma atividade de Revisão e de Execução de alteração . O item de trabalho normalmente executa essas atividades na ordem.
Quando um item de trabalho é criado, a primeira atividade do Service Manager se torna ativa e permanece ativa enquanto o Service Manager (ou o usuário) executa qualquer trabalho que a atividade represente. Quando esse trabalho é concluído, o Service Manager marca a primeira atividade como Concluída e ativa a próxima atividade na sequência. Quando a atividade final na sequência é marcada como Concluída, o Service Manager marca todo o item de trabalho como Concluído.
Algumas atividades do Service Manager podem ser executadas manualmente, como a atividade Revisar de uma Solicitação de Alteração. Outras atividades do Service Manager podem ser automatizadas, como uma atividade que envia um email para um usuário. A atividade Execução de Alteração 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 do WF no Service Manager usa a atividade Definir Status da Atividade como Concluída . 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. A definição desse status aciona o sistema para mover para a próxima atividade no item de trabalho, e esse processo se repete até a última atividade no item de trabalho ser concluída.
A atividade Definir Status da Atividade como Concluída usa uma entrada, ID da Atividade, que identifica a atividade do Service Manager na qual agir. Em seguida, a atividade WF se conecta ao servidor de gerenciamento do Service Manager, recupera a atividade especificada do Service Manager do banco de dados, define seu status como Concluído e a salva de volta no banco de dados. A maioria dos exemplos de código que são incluídos neste exemplo é proveniente 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. Essa atividade é baseada na classe WorkflowActivityBase e usa a classe do validador SetActivityStatusToCompletedValidator e a classe do designer WorkflowActivityBaseDesigner.
A classe WorkflowActivityBaseDesigner contém as personalizações descritas na seção anterior, Benefícios do uso da classe WorkflowActivityBase. Você pode posteriormente estender e personalizar essa classe.
A primeira seção da definição da atividade dessa 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 para a atividade WF de exemplo
O código declara uma propriedade, ActivityId, como uma propriedade de dependência. Isso significa que essa propriedade pode ser associada aos parâmetros que são definidos no nível do fluxo de trabalho. Nesse caso, a ID da atividade Service Manager é passada 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 na atividade WF de exemplo
O método Execute executa o trabalho real dessa atividade WF. No escopo do método Execute , a atividade WF procede da seguinte maneira:
Detecta se ele está operando em 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 Service Manager, obtém a propriedade Status da atividade Service Manager recuperada e define a propriedade como o valor da lista de enumeração Completed .
Confirma as alterações na atividade Service Manager.
Usa o método TrackData (parte da infraestrutura WF) para registrar informações de controle sobre a execução e o status da atividade 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 na atividade WF de exemplo
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á completamente definida ou se ainda exige que uma ou mais entradas sejam definidas. A Ferramenta de Criação indica um erro de validação semelhante ao Visual Studio usando um ícone de ponto de exclamação vermelho (!) na atividade de fluxo de trabalho no painel 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 a atividade WF de exemplo em um fluxo de trabalho
A atividade Definir Status da Atividade como Concluída está incluída no painel Caixa de Ferramentas de Atividades padrão da Ferramenta de Criação. Para obter mais informações sobre como adicionar atividades personalizadas ao painel Caixa de Ferramentas de Atividades, consulte Como instalar um assembly de atividade personalizado.
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 Criação oferece os seguintes benefícios:
Usuários sem habilidades de desenvolvimento podem criar fluxos de trabalho; eles não precisam trabalhar diretamente com código.
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 a 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ído . Esse 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 que são mostradas posteriormente neste exemplo. Quando o fluxo de trabalho é executado, 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 Status da Atividade como Concluída. 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
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 em que gera o código de fluxo de trabalho e compila o fluxo de trabalho .dll arquivo, 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, é associado a um pacote de gerenciamento de exemplo, chamado Woodgrove.AutomatedActivity.AddComputerToGroupMP.xml. Este pacote de gerenciamento estende o processo 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 gerenciamento de alterações, ela aciona 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 será a última etapa após alguma outra tarefa executada por outras atividades WF no fluxo de trabalho.
A seção Monitoring do pacote de gerenciamento contém a definição Rule do fluxo de trabalho. Sucessivamente, a definição 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 deve ser 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 do gatilho é 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$, associa-a 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 tentativas executar 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 servidor de gerenciamento específico do Service Manager, todos os arquivos relacionados ao fluxo de trabalho devem residir nesse servidor. Esses arquivos incluem o seguinte:
Os arquivos de assembly da atividade WF. Se você estiver usando apenas as atividades do WF do Service Manager, por padrão, os arquivos apropriados serão instalados. Se você estiver usando atividades personalizadas, consulte Como instalar um assembly de atividade personalizada.
O arquivo de assembly do fluxo de trabalho, nesse 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.
Próximas etapas
- Defina o status de uma atividade como concluída para a atividade de exemplo da Ferramenta de Criação do Service Manager.