Diretrizes para criação de atividades personalizadas
Publicado: julho de 2016
Aplicável a: System Center 2012 SP1 - Service Manager, System Center 2012 R2 Service Manager, System Center 2012 - Service Manager
O System Center 2012 - Service Manager automatiza uma variedade de processos de TI (tecnologia de informação). Para o processo de Gerenciamento de Incidentes, por exemplo, o System Center 2012 - 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.
O System Center 2012 – Ferramenta de Criação do Service Manager fornece um método fácil de usar de criação de 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, o Ferramenta de Criação compila o novo fluxo de trabalho em um conjunto de definições, código e conteúdo de 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á ocorrendo nos bastidores do Ferramenta de Criação pode ser benéfico para usuários mais avançados. Primeiro, 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 a 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 a ferramenta de desenvolvimento de sua escolha, como o sistema de desenvolvimento do Microsoft Visual Studio.
Atividades de fluxo de trabalho e a classe WorkflowActivityBase
Os fluxos de trabalho do Service Manager usam atividades do WF. Para trabalhar facilmente com o 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 Activity genérica de atividades do WF.Para obter mais informações sobre como definir atividades do WF usando a classe base Activity genérica, consulte Activity Class.
Vantagens 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 Ferramenta de Criação Criação. No entanto, essas atividades se comportam da mesma forma que no ambiente do Visual Studio Design. Elas não têm as personalizações que são criadas na biblioteca de atividades do Service Manager.
.jpeg "System_CAPS_ICON_note.jpg"){kind=icon} Observaçã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 do Ferramenta de Criação (classe base WorkflowActivityBase) | Atividade WF do Visual Studio (classe base Activity) |
|---|---|---|
| O usuário associa propriedades de atividade (a propriedades de objeto do Service Manager ou a propriedades de outras atividades). | Chama a caixa de diálogo Associar propriedade a que é personalizada para usuários do Service Manager. | Chama a caixa de diálogo Associar propriedade a que foi criada para 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. |
.jpeg "System_CAPS_ICON_important.jpg") Importante |
|---|
|
Os usuários podem criar atividades WF personalizadas no Visual Studio para usar no Ferramenta de Criação. No entanto, para aproveitar o comportamento de tempo de design personalizado do Ferramenta de Criação, as atividades personalizadas devem ser baseadas na classe WorkflowActivityBase, e não na classe Activity.
Atividades de Fluxo de Trabalho e Atividades Automatizadas do Service Manager
As atividades WF podem interagir com um tipo diferente de atividade, as atividades do Service Manager que são usadas por 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 acompanham unidades de trabalho, como Incidentes, Solicitações de Serviço, Solicitações de Alteração e outras unidades de trabalho. A maioria dos itens de trabalho contém 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) realiza qualquer trabalho que a atividade representa. 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 Revisão de uma Solicitação de Alteração. Outras atividades do Service Manager podem ser automatizadas, como uma atividade que envia um email a um usuário. A atividade Execução de Alteração de uma Solicitação de Alteração pode ser automatizada. O Service Manager usa os fluxos de trabalho 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 WF no Service Manager usa a atividade WF Definir Status da Atividade como Concluída. Essa atividade WF geralmente representa a última etapa em um fluxo de trabalho que implementa uma atividade automatizada do Service Manager e ela define o status dessa atividade como Concluída. 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, Activity ID, que identifica a atividade do Service Manager na qual agir. Em seguida, a atividade WF conecta ao servidor de gerenciamento do Service Manager, recupera a atividade do Service Manager especificada do banco de dados, define seu status como Concluída e a salva novamente 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.
Inicializando 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 que são descritas na seção anterior, "Vantagens de usar a 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 da 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 é transmitida 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, se estiver, define as propriedades adequadas da atividade WF.
Conecta 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 do Service Manager recuperada e define a propriedade como o valor da lista de enumeração Completed.
Confirma as alterações feitas na atividade do 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. O Ferramenta de Criação indica um erro de validação de forma semelhante ao Visual Studio, usando um ícone de ponto de exclamação vermelho (!) na atividade de fluxo de trabalho do 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;
}
}
}
Usando a atividade WF de exemplo em um fluxo de trabalho
A atividade Definir status da atividade como concluída está incluída no painel Ferramenta de Criação padrão Caixa de ferramentas de atividades.Para obter mais informações sobre como adicionar atividades personalizadas ao painel Caixa de ferramentas atividades, consulte Como instalar um Assembly de atividade personalizada na Ferramenta de Criação online.
Você pode usar o painel de criação do Ferramenta de Criação para criar fluxos de trabalho de uma maneira semelhante ao uso da interface de design do fluxo de trabalho do Visual Studio. No entanto, a Ferramenta de Criação oferece os seguintes benefícios:
Os 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 no Ferramenta de Criação, a ferramenta gera o código Visual C# e XOML correspondente e compila-o 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 do Visual C# para o fluxo de trabalho
O exemplo a seguir mostra o código do Visual C# que o Ferramenta de Criação gera para um exemplo de fluxo de trabalho que usa a atividade Definir Status da Atividade como Concluída. 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, o Service Manager identifica o valor e o transmite 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 do fluxo de trabalho
O WF usa o formato XOML para algumas das definições de fluxo de trabalho. No caso do exemplo de fluxo de trabalho, o 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.
Declarando o fluxo de trabalho e sua condição do gatilho em um Pacote de Gerenciamento
O Service Manager não pode usar um arquivo .dll de fluxo de trabalho isolado; 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 ele gera o código de fluxo de trabalho e compila o arquivo .dll do fluxo de trabalho, o 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. Esse pacote de gerenciamento estende o processo Gerenciamento de alterações com uma nova Service Manager automatizada. 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 o 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ída. 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.
No caso do exemplo de fluxo de trabalho, o elemento DataSource contém um elemento Subscription, que especifica se o fluxo de trabalho deve ser executado quando uma instância da classe AddComputerToGroup (uma classe Service Manager personalizada) muda o estado para Ativo.
<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>
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 Service Manager que é registrada no elemento DataSource.
O elemento WriteAction também armazena os detalhes opcionais de configuração do 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>
</Rule>
</Rules>
</Monitoring>
Importando o Pacote de Gerenciamento
Para o fluxo de trabalho executar 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 WF do System Center 2012 - Service Manager, por padrão, os arquivos adequados serão instalados. Se você estiver usando atividades personalizadas, consulte Como instalar um Assembly de atividade personalizada na Ajuda online do Ferramenta de Criação.
O arquivo de assembly do fluxo de trabalho, nesse caso, SetActivityStatusToCompleteWF.dll. Você deve copiar esse arquivo para o servidor de gerenciamento Service Manager.
O arquivo do pacote de gerenciamento, nesse caso, Woodgrove.AutomatedActivity.AddComputerToGroupMP.xml. Você deve copiar esse arquivo para o servidor de gerenciamento Service Manager.
Quando todos os arquivos estiverem no local adequado, 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 que tiver importado o pacote de gerenciamento, o fluxo de trabalho estará pronto para ser executado sempre que a condição definida como seu gatilho for atendida.
Consulte também