Compartilhar via

Este artigo foi traduzido por máquina.

Team Foundation Server e Exchange

Crie um sistema de tíquetes usando o Exchange e o Team Foundation Server

Mohammad Jalloul

Baixar o código de exemplo

Team Foundation Server (TFS) fornece um excelente mecanismo para criar e gerenciar permissões por meio de sua funcionalidade de rastreamento de item de trabalho eficientes. Tal controle normalmente é feito de duas maneiras. No primeiro, um representante de suporte com acesso ao TFS por meio de sua interface de Web (conhecido como o TSWA, ou Team System Web Access) cria um tipo de item de trabalho personalizada para um tíquete de suporte, inserindo os detalhes necessários. O segundo método, uma interface é criada ao redor a funcionalidade do item de trabalho e simplificar o acesso a ele para usuários externos que não precisa saber sobre o TFS. O item de trabalho, em seguida, é geralmente atribuído a um engenheiro de software que rastreia e gerencia o item de trabalho a partir de Visual Studio. O objetivo dos dois métodos é mover a criação de ticket de sistemas de banco de dados proprietários ou de email ao TFS devido a suas vantagens muitos — em particular que o trabalho do TFS itens têm um fluxo de trabalho que define o ciclo de vida de um tíquete. Qualquer pessoa pode controlar de um tíquete de monitoramento de alterações para o item de trabalho e exibindo o histórico de itens de trabalho. Integração com o data warehouse do TFS fornece um benefício extra, como você pode aproveitar os poderosos recursos de emissão de relatórios do Reporting Services (SSRS) da SQL Server ou Serviços do Excel.

Apesar de tais métodos e-mails freqüentemente obtém enviados ao redor de qualquer forma, para explicar o problema mais ou para adicionar mais detalhes. Essas informações adicionais do thread-mail às vezes serão perdidas e outras vezes é copiado manualmente para o histórico de itens de trabalho para manter o contexto do item de trabalho completo possível. Esta intervenção manual anula a finalidade de itens de trabalho e pode eliminar a produtividade que itens foram projetados para fornecer o trabalho.

Um terceiro método se apresentarei neste artigo que tira o melhor dos dois mundos: email e itens de trabalho. Essa abordagem começa com o correio eletrônico — assim como suporte representantes têm feito por um longo tempo.

Serviços da Web do Exchange

O processo que apresentarei usa a energia do Microsoft Exchange Web Services (EWS) para assinar as notificações para os e-mails enviados para uma lista de distribuição do Exchange 2007/2010. O serviço de escuta da Web cria um item de trabalho com base em qualquer novo email recebido. Qualquer relacionados ao mesmo segmento de e-mails subseqüentes serão acrescentados no histórico de item de trabalho, usando os recursos de rastreamento de conversação do de Microsoft Exchange Server, espelhamento, portanto, o encadeamento de e-mails do item de trabalho. O item de trabalho também mantém um fluxo de trabalho. Dessa forma os usuários — os representantes de suporte — não está alterando seus hábitos de adaptar-se a uma nova tecnologia; em vez disso, a tecnologia está levando seu processo e automatizando a ele.

Figura 1 mostra como o processo geralmente fluirá.

Process Flow for the Support Ticket Work Item

Figura 1 o fluxo de processo para o Item de trabalho do tíquete de suporte

A seguir explica o fluxo mais detalhadamente:

  1. O fluxo inicia quando um representante de suporte é notificado de um problema com um produto.
  2. O representante de suporte envia um email descrevendo o problema de uma lista de distribuição (DL) no Exchange. O DL inclui qualquer pessoa que precisa saber sobre o problema e pode atribuir ao desenvolvedor adequado para resolvê-lo. O DL também contém uma conta de email de "observador" existe apenas para fins de notificação. A conta do Inspetor está registrada com o Exchange para que ele receberá notificações em um endereço específico de serviço da Web.
  3. Exchange processa o email, o roteamento para todos os membros da lista de distribuição e envio de notificações para todos os serviços da Web que são registrados para recebê-los para uma conta de email especificado.
  4. O tíquete de suporte de serviço da Web recebe uma notificação do Exchange por meio de sua interface de serviço da Web.
  5. O serviço da Web processa a notificação e solicita informações adicionais relacionadas ao endereço de email. Em seguida, ele cria um item de trabalho de solicitação de suporte no TFS, que é preenchida com informações extraídas do email.
  6. Os membros do DL também receberem email e eles podem responder, pedindo para obter mais informações, enviará o representante de suporte. Porque o DL está incluído no campo para ou CC de campos da mensagem de email, a conta de email do Inspetor está ciente deste e de serviço da Web de notificações recebe notificações de todos os e-mails acontecendo no segmento. TFS atualiza o item de trabalho de solicitação de suporte com as informações adicionais.
  7. A permissão é atribuída a um desenvolvedor usando o campo Assigned To o solicitação de suporte do item de trabalho apenas criado.
  8. O desenvolvedor começa a trabalhar em um problema, alterando o estado do item de trabalho em andamento. Quando o código que contém a correção é revisado, testado e concluído, ele será verificado. O conjunto resultante de alterações é associada ao item de trabalho de solicitação de suporte. Este item de trabalho agora controla tanto a conversação de email como o conjunto de alterações relacionadas na correção.
  9. Se o representante de suporte tem acesso ao TFS, a solicitação de suporte podem ser atribuída a ele para o fechamento. Caso contrário, o DL pode ser notificado por email. Normalmente, clientes potenciais e os gerentes de projeto irá configurar alertas do TFS para que eles são notificados quando um item de trabalho de solicitação de suporte foi resolvido. Isso ocorre quando o item de trabalho é alterado de em andamento para concluído.

O processo é, na verdade, semelhante ao que normalmente ocorre em cenários reais, envolvendo questões de suporte — exceto, na vida real, o segmento de email e o sistema de registro é geralmente dois sistemas completamente diferentes e separados.

O serviço da Web de notificações de tíquete de suporte

O serviço da Web de notificações de tíquete de suporte usa o EWS gerenciados API, que permite gerenciados.NET se comunicarem com EWS usando interfaces documentadas via familiar de mensagens baseados em SOAP. Você encontrará uma descrição detalhada da API gerenciada do EWS em bit.ly/jGKRgG.

EWS não é uma parte normal de uma instalação do Microsoft Exchange e muitas configurações IT, ele é instalado em um servidor de acesso para cliente do Exchange separado. Para ser usada, os serviços de tem que ser instalado e configurado com o Microsoft Exchange. Você precisará obter a URL do serviço Web de EWS de seus administradores do Exchange serão algo parecido com https://hostname/EWS/Exchange.asmx. Observe que esses serviços da Web são normalmente configurados em um ponto de extremidade SSL.

A versão mais recente da API do EWS gerenciados no momento da redação deste artigo é 1.1. Esta versão suporta Microsoft Exchange Server 2007 SP1 por meio do SP1 do Exchange Server 2010. Você pode baixá-lo do bit.ly/mkb7Is.

Por padrão, ele copiará os arquivos para [arquivos de programa] \Microsoft\Exchange\Web Services\1.1. A API é empacotada em um único assembly denominado Microsoft.Exchange.WebServices.dll. The installation folder includes two important files you should review before starting to work with the API: Readme.htm file and GettingStarted.doc.

A primeira etapa na interação com o EWS é criar um serviço da Web para ouvir notificações proveniente do Exchange. Depois que este serviço da Web é criado, ele deve ser registrado com o Exchange para iniciar o recebimento de notificações.

O SDK dos serviços Microsoft Exchange Server 2010 SP1 Web simplifica a criação de tais serviços da Web. Você pode baixar a versão de outubro de 2010 (a versão mais recente no momento da redação deste artigo) em bit.ly/kZtjLq.

O SDK torna muito mais fácil criar o primeiro serviço da Web. Ele contém quatro exemplos que explore a diferentes áreas direcionadas pela API. Você pode acessar as amostras depois de instalar o SDK, navegando até o menu Iniciar | Todos os programas | Exchange Server 2010 SP1 SDK dos serviços da Web | Outubro de 2010 | Exchange Server diretório de amostra 2010 SP1 Web Services SDK. O exemplo que é de particular interesse é o PushNotification, que demonstra um serviço de Web de notificações de envio que escuta e processa as notificações de entrada do Exchange. Este exemplo também contém um aplicativo cliente, que você pode usar para criar uma inscrição em troca de serviço da Web. Usando o exemplo de como uma implementação básica se torna mais fácil de compreender a maneira como o EWS works e para verificar se todas as peças necessárias são funcionais.

Inscrevendo-se com o Exchange

Você precisará de uma conta do Exchange para criar uma assinatura de notificações com o Exchange. A inscrição irá configurar o roteamento de modo que os e-mails enviados para a caixa de correio da conta resultará no Exchange, fazendo uma chamada para o serviço de notificações registrado para essa conta. Observe que é possível registrar mais de uma notificação de qualquer determinada conta. Na verdade, é possível criar mais de uma assinatura para o mesmo ponto de extremidade de serviço de Web. Da perspectiva do Exchange e o EWS, isso é perfeitamente legítimo.

O único requisito para serviços da Web registrado com EWS é que eles implementem uma determinada interface, INotificationServiceBinding, que tem a seguinte assinatura:

public interface INotificationServiceBinding {
  SendNotificationResultType SendNotification(
    SendNotificationResponseType sendNotification);
}

O único requisito é que o serviço da Web contém uma implementação do método SendNotification. Este é o método da Web que será chamado pelo Exchange sempre que uma correspondência os atributos de assinatura de email é recebido.

Voltando a amostra de PushNotification e, em particular, o aplicativo de console de PushNotificationSubscriber, fica claro o que implica a uma assinatura. Figura 2 mostra o método SubscribeForPushNotification retirado o arquivo PushNotificationSubscriber.cs.

Figura 2 código de assinatura do exemplo PushNotification

public static void SubscribeForPushNotifications()
{
  System.Net.ServicePointManager.ServerCertificateValidationCallback =
    delegate(Object obj, X509Certificate certificate, X509Chain chain,
    SslPolicyErrors errors)
  {
      // Replace this line with code to validate server certificate.
return true; 
  };

  // Create the bindings and set the credentials.
ExchangeServiceBinding esb = new ExchangeServiceBinding();
  esb.Url = "https://CAS01.contoso.com/EWS/exchange.asmx";
  esb.Credentials = new NetworkCredential("username", "password", "domain");

  // Create a new subscription.
SubscribeType subscribeRequest = new SubscribeType();
  PushSubscriptionRequestType pushSubscription = 
    new PushSubscriptionRequestType();

  // Subscribe to events in the inbox folder.
BaseFolderIdType[] folders = new BaseFolderIdType[1];
  DistinguishedFolderIdType folderId = new DistinguishedFolderIdType();
  folderId.Id = DistinguishedFolderIdNameType.inbox;
  folders[0] = folderId;
  pushSubscription.FolderIds = folders;

  // Subscribe to all events.
NotificationEventTypeType[] eventTypes = 
    new NotificationEventTypeType[6];
  eventTypes[0] = NotificationEventTypeType.NewMailEvent;
  eventTypes[1] = NotificationEventTypeType.CopiedEvent;
  eventTypes[2] = NotificationEventTypeType.CreatedEvent;
  eventTypes[3] = NotificationEventTypeType.DeletedEvent;
  eventTypes[4] = NotificationEventTypeType.ModifiedEvent;
  eventTypes[5] = NotificationEventTypeType.MovedEvent;
  pushSubscription.EventTypes = eventTypes;

  // Receive push notifications every 1 minutes.
pushSubscription.StatusFrequency = 1;

  // Identify the location of the client Web service.
pushSubscription.URL = "http://clientWebService/Service.asmx";

  // Form the subscribe request.
subscribeRequest.Item = pushSubscription;

  // Send the subscribe request and get the response.
SubscribeResponseType subscribeResponse = 
    esb.Subscribe(subscribeRequest);

  // Check the result.
if (subscribeResponse.ResponseMessages.Items.Length > 0 &&
    subscribeResponse.ResponseMessages.Items[0].ResponseClass ==
      ResponseClassType.Success)
  {
    SubscribeResponseMessageType subscribeResponseMessage =
      subscribeResponse.ResponseMessages.Items[0] as   
        SubscribeResponseMessageType;

      using (StreamWriter sw = new StreamWriter("MailboxEventLog.txt"))
      {
        sw.WriteLine("Subscribed for Push notifications: {0}", 
          subscribeResponseMessage.SubscriptionId);
      }
  }

  CreateXmlMessageTextFile(subscribeRequest, subscribeResponse);

}

Inclui o código de a Figura 2 aqui porque ele ilustra que a chave recursos disponíveis quando registrar uma assinatura. Em particular, observe como o exemplo atribui a primeira parte da informação, a URL do servidor de acesso para cliente:

esb.Url = "https://CAS01.contoso.com/EWS/exchange.asmx";

Depois, ele usa as credenciais da conta de e-mail para autenticar com EWS:

esb.Credentials = new NetworkCredential("username", "password", "domain");

Observe também que depois de criar um objeto de assinatura, você pode configurá-lo para que ele assina somente para determinados eventos (novo email, copiar, mover, excluir, modificar e assim por diante) ou para pastas de email específico. Isso fornece grande flexibilidade, como você pode delegar a filtragem para o Exchange em vez de inscrever-se em todos os eventos e filtragem no aplicativo mais tarde.

Finalmente, observe a propriedade StatusFrequency. Este é um valor numérico que define, em minutos, com que freqüência o Exchange envie chamadas de pulsação para o serviço da Web para certificar-se de que o ponto de extremidade registrado is alive. Isso ajuda a Exchange cancelar inscrições para pontos de extremidade não são mais válidos, como para um serviço da Web que é movido para um novo host e, portanto, tem um novo URL. Se você esquecer sua inscrição antes de mover o serviço da Web, a inscrição pode durar indefinidamente e Exchange seria manter enviar notificações desnecessariamente a um ponto de extremidade inexistente.

Agora vamos examinar a implementação personalizada para oferecer suporte a criação de itens de trabalho do TFS de solicitação de suporte. A melhor maneira de apresentar a funcionalidade é começar com uma demonstração do serviço da Web e nos aprofundar em implementação.

Implantando o serviço da Web

O projeto de código que acompanha este artigo contém um Web service e vários outros artefatos de suporte. Não há nenhum aplicativo de console separado para cuidar do registro, pois ele foi criado para o serviço da Web.

Após a criação, o serviço da Web pode ser implantado a partir de 2010 de Visual Studio ou copiando o site pré-compilado resultante para um host. Você precisará criar manualmente o aplicativo da Web e um pool de aplicativos correspondentes. Defina a identidade do pool de aplicativos para a conta de usuário do observador. Isso é importante porque o serviço da Web pode representar a identidade do pool de aplicativos e use-o para realizar a inscrição. Isso tem duas vantagens:

  1. As credenciais não terá que ser inseridos novamente sempre que o serviço da Web precisa ser registrado.
  2. As credenciais não precisarão ser armazenado, onde eles podem estar acessíveis para usá-los para assinar novamente.

O serviço da Web precisa ter permissões de gravação para duas pastas: a pasta na qual ele grava logs e a pasta em que ele usa como o cache do TFS. Além disso, você precisará definir as seguintes configurações Web. config, pois eles dependem de um ambiente específico onde o serviço da Web é usado:

  • EWSServiceUrl: O URL do serviço de Exchange; obter este URL de administradores do Exchange.
  • TeamFoundationServerUrl: A URL do TFS coleção onde os itens de trabalho são implantados de projeto (por exemplo: http://<servername>:8080/tfs/).
  • WorkItemTeamProject: O nome do projeto da equipe TFS que contém o tíquete de suporte ao item de trabalho tipo (por exemplo: SupportWorkFlow).
  • WorkItemType: O nome real do tíquete de suporte de item de trabalho tipo (por exemplo: Support Request). Se o item de trabalho for renomeado ou digite do Web service é usado para oferecer suporte a algum outro item de trabalho (como mostrarei neste artigo), você pode usar isso para definir o nome do novo item de trabalho.
  • RequestSupportTeamName: O item de trabalho contém um campo de "Solicitação de equipe de suporte" para direcionar as diferentes equipes de suporte a diferentes tarefas. Isso é orientado por uma lista global chamada equipes na definição de item de trabalho. Para usar esse recurso, manter a definição de campo e crie a lista global (instruções estão incluídas na próxima seção deste artigo, "Configurando o Item de trabalho") e atribuir um dos valores da lista global para a chave de configuração de RequestSupportTeamName (por exemplo: atendimento ao cliente). Caso contrário, remova a lista global para o campo e a restrição "Required" o item de trabalho e deixe o valor da chave RequestSupportTeamName em branco.

Neste momento, o serviço da Web está pronto para ser usado. Você pode verificar ele está configurado corretamente usando o Gerenciador do IIS no servidor Web para navegar até a pasta de aplicativo da Web (Lembre-se de clicar na guia modo de exibição de conteúdo na parte inferior se usando o IIS 7 ou posterior). Em seguida, clique com o botão direito no arquivo asmx e clique em Procurar, como mostrado na a Figura 3. Você deverá ver uma página da Web, idêntica ao mostrado na a Figura 4.

Browsing to the ASMX Page

Figura 3 Navegando na página ASMX

Default Web Service URL with localhost as the Host

Figura 4 URL de serviço da Web padrão com localhost como o Host

Antes de começar a usar o serviço da Web, você precisará importar o item de trabalho no TFS. Este artigo presume que você estiver usando o TFS 2010, mas o mesmo item de trabalho e o serviço da Web podem ser usados com o TFS 2008.

Configurando o Item de trabalho

O código de exemplo deste artigo (que pode ser baixado em code.msdn.microsoft.com/mag201108TFS) contém uma amostra suporte tíquete work item type chamado Support Request. Para exibir a definição de tipo de item de trabalho, o fluxo de trabalho e o layout antes para importar no TFS, você precisará instalar o TFS Power Tools, disponível em bit.ly/hyUNqo. Quando você instala o TFS Power Tools, um novo menu chamado Editor de processo é adicionado ao IDE Visual Studio no menu Ferramentas. Clique duas vezes em Request.xml de suporte (localizada sob a pasta de Item de trabalho na solução de exemplo). A janela do Editor de Item de trabalho será carregada com três guias: campos, Layout e fluxo de trabalho, como mostrado na a Figura 5.

Workflow for the Support Ticket Work Item
(clique para ampliar)

Figura 5 o fluxo de trabalho para o Item de trabalho do tíquete de suporte

O fluxo de trabalho do item de trabalho mostra os diferentes estados que ofereça suporte a item de trabalho: novo, quando o item de trabalho é criado pela primeira vez; Em andamento, quando o problema documentado no item de trabalho está realmente sendo trabalhado; e feito, quando o trabalho em um problema termina.

Se você decidir configurar o campo de solicitar a equipe de suporte, conforme discutido anteriormente, localize o campo de solicitar a equipe de suporte sob a guia de campos, clique duas vezes para abrir a caixa de diálogo de definição de campo e, em seguida, clique na guia regras. Se você não planeja usar este campo, basta exclua as duas regras listadas (ALLOWEDVALUES e obrigatória). If you do want to use the field but would like to configure it to use a different global list, double-click on the ALLOWEDVALUES rule and then on the only entry present: GLOBALLIST: Equipes. Na caixa de diálogo Editar do Item de lista, selecione uma lista global e clique em OK.

Se você não tiver uma lista global de configurar ainda, você pode criar um (você precisará ter permissões de administrador do TFS):

  1. No IDE de Visual Studio, vá para ferramentas | Editor de processo | Lista global e em seguida, clique em abrir a lista Global do servidor.
  2. Você será apresentado com uma caixa de diálogo. Selecione a coleção de projeto de equipe e clique em conectar.
  3. Na caixa de diálogo lista Global, clique com o botão direito em qualquer item e, em seguida, clique em nova lista Global.
  4. Digite um nome para a lista global. You can keep the same name as in the work item: Equipes.
  5. A nova lista global com o botão direito e clique em Novo Item. Repita essa etapa para tantas vezes quanto necessário para inserir os nomes da equipe.
  6. Clique em OK para salvar a nova lista global.

Observe que se você deu a nova lista global de um nome diferente, você precisará editar o item de trabalho e atualizar a sua definição com o nome da lista global.

Neste ponto, tudo o que resta é importar o item de trabalho no TFS, da seguinte forma:

  1. No IDE de Visual Studio, vá para ferramentas | Editor de processo | Tipos de Item de trabalho e em seguida, clique em Importar WIT (WIT significa o tipo de Item de trabalho).
  2. Clique no botão Procurar e navegue até o local do arquivo de Request.xml de suporte.
  3. No projeto para importar a lista, clique no nome do projeto da equipe do TFS na qual você deseja importar o item de trabalho e, em seguida, clique em OK.

Você pode verificar que o item de trabalho foi importado com êxito no TFS clicando com o botão direito no nó Work Items para esse projeto de equipe a partir de Team Explorer e expandindo a janela do novo Item de trabalho. Você deve ver a solicitação de suporte como uma das opções disponíveis. Se você não estiver visível, clique no nó de itens de trabalho e, em seguida, clique em Atualizar.

Criar uma inscrição

Conforme mostrado na a Figura 4, o serviço da Web possui três métodos: Verificar Status, SendNotification e inscrever-se. O método da Web de inscrição é usado para criar inscrições de notificação.

O processo de inscrição será criar uma inscrição para a conta de usuário é definida como a identidade do Pool de aplicativos de serviço da Web. Para usar as notificações, efetivamente, que conta — a conta watcher — deve ser parte de uma lista de distribuição é a serem monitorados, conforme mostrado na a Figura 6.

Adding the Watcher E-mail Account to a Distribution List

Figura 6 adicionando a conta de email do Gerenciador para uma lista de distribuição

Para criar uma assinatura, clique no link Inscrever-se na página da Web mostrado na a Figura 4. Em seguida, clique no botão Invoke na página da Web resultante. Se conseguir, você verá uma identificação de assinatura. Isso também é registrado para a pasta de logs, definida no arquivo Web. config.

Os detalhes da assinatura são registrados em dois arquivos. O primeiro faz a solicitação enviada para EWS para realizar a inscrição e tem o formulário SubscribeType-<timestamp>. XML. O segundo arquivo registra a resposta recebida do EWS para confirmar a inscrição e tem o formulário SubscribeResponseType-<timestamp>. XML. Um terceiro arquivo chamado SubscriberEventLog.txt registra todos os eventos recebidos pelo serviço da Web do Exchange, incluindo um evento de status da pulsação a cada minuto e os eventos de novos emails sempre que estiver sendo acionados.

O status da inscrição pode ser verificado a qualquer momento chamando o método CheckStatus Web, que produz um resultado semelhante ao mostrado na a Figura 7, que mostra a hora do último evento de pulsação foi recebido e o status da assinatura do serviço da Web. If there’s an active subscription, you’ll see “Status: Subscribed,” as shown in the figure.

Sample Output from the CheckStatus Web Method

Figura 7 a saída de exemplo do método CheckStatus Web

O processo geral é representado no diagrama de seqüência em a Figura 8.

The Subscription and Notification Process

Figura 8 O processo de notificação e de assinatura

Usando o sistema de tickets

A maneira mais fácil para começar a usar o sistema de tickets é simular um cenário real e envie um e-mail para a lista de distribuição que contém a conta do observador. Figura 9 mostra um exemplo de email para o DL mostrado na a Figura 6, e a Figura 10 mostra o item de trabalho de solicitação de suporte que é gerado como resultado de notificação enviada do Exchange para o serviço da Web de notificações.

The First E-mail in a Mail Thread

Figura 9 O primeiro E-mail em um segmento de email

The Work Item Generated as a Result of the First E-mail
(clique para ampliar)

Figura 10 O Item de trabalho gerado como resultado do primeiro E-mail.

Figura 11 mostra o resultado do envio de outros e-mails como parte do mesmo segmento de email e como que é traduzido para o histórico de itens de trabalho. O primeiro thread obtém uma cor distinta para o seu cabeçalho. O restante dos threads obter outra cor distinta (amarelo nesse caso, mas as cores podem ser configuradas no Web. config).

The Work Item After a Second E-mail
(clique para ampliar)

Figura 11 O Item de trabalho após um segundo email.

O código de personalização

Agora vamos dar uma olhada em diversas partes do código que tornam o sistema se operar. O código de exemplo deste artigo contém uma solução de 2010 de Visual Studio chamada Email2Workitem.sln. When you load this solution in Visual Studio, you’ll see that the structure is divided into four solution folders: Diagrams, Subscription Library, Web Service and Work Item.

Na maior parte, o serviço da Web baseia-se na amostra PushNotification SDK. No entanto, fiz algumas alterações para manter a solução genérica e fácil de usar. Vou pesquisar sobre as alterações e as personalizações feitas para transformar o exemplo em uma solução de tickets.

A primeira alteração principal é a funcionalidade que permite que o processo de inscrição a ser integrado ao serviço da Web. Isso é crucial porque permite que o serviço da Web inscrever-se sem a necessidade de gerenciar as credenciais da conta. Às vezes, a assinatura precisa ser renovada, como, por exemplo, passa quando o servidor que hospeda o serviço da Web por algumas atividades de manutenção, por exemplo. Quando isso acontece, os Pools de aplicativo normalmente são interrompidos e Exchange cancela as inscrições porque o evento de pulsação não obtém nenhuma resposta. A renovação automática da assinatura é obtida chamando o método InitializeTimer no construtor de serviço da Web. InitializeTimer, mostrado na a Figura 12, cria um timer com um intervalo especificado no Web. config. Este timer é responsável pela renovação de uma inscrição depois de interrupções de serviço, por exemplo.

Figura 12 O método InitializeTimer

private void InitializeTimer()
{
  int autoSubscribeTimeoutThresholdInMinutes = Convert.ToInt32(
    ConfigurationManager.AppSettings["AutoSubscribeTimeoutThresholdInMinutes"]);
 
    lock (_pollingTimerSyncLock)
    {
      if (autoSubscribeTimeoutThresholdInMinutes > 0)
      {
        // Seed the timer with the polling interval specified in config.
if (_pollingTimer == null)
        {
          TimerCallback timerCallback = OnTimedEvent;
          _pollingTimer = new Threading.Timer(timerCallback, null, 0, 
          _pollingIntervalInMilliseconds); // Enable the timer.
}
      }
      else
      {
        // Dispose of the timer.
if (_pollingTimer != null)
        {
          _pollingTimer.Dispose();
          _pollingTimer = null;
        }
      }
    }
}

A segunda alteração importante tem a ver com a mensagem de entrada para determinar se ele é o primeiro e-mail em um thread de inspeção. Figura 13 mostra essa funcionalidade.

Figura 13 Determinando o primeiro E-mail em um Thread

// Get either the folder or item identifier for a 
// create/delete/new mail event.
if (bocet.Item is ItemIdType)
{
  // Get the item identifier.
ItemIdType itemId = bocet.Item as ItemIdType;
 
  //
  // Get the message using the ItemIdType.
//
 
  // From web.config
  string ewsServiceUrl = 
    ConfigurationManager.AppSettings["EWSServiceUrl"];
 
  ExchangeService esb = 
    new ExchangeService(ExchangeVersion.Exchange2010);
  esb.Url = new Uri(ewsServiceUrl);
  // From Web service App Pool identity.
esb.UseDefaultCredentials = true;
 
  EmailMessage message = EmailMessage.Bind(esb, new ItemId(itemId.Id));
  ConvertEmailToRequestItem(message);
}

Observe como o código utiliza o fato de que a identidade do Pool de aplicativos do serviço Web é que a conta de email, o que significa que a Web chama para recuperar os detalhes da mensagem de email pode ser feito sem ter que inserir credenciais.

O método ConvertEmailToRequestItem faz o grosso do trabalho. Para determinar se um email é a primeira parte de um thread ou email, ele utiliza o ConversationIndex propriedade da instância de EmailMessage. O comprimento da matriz de 
byte ConversationIndex é 22, quando ele é o primeiro e-mail. E-mails subseqüentes em um thread obtém mais bytes adicionados para o ConversationIndex. ConvertEmailToRequestItem usa isso para determinar se a tratar o email como uma nova mensagem e criar um novo item de trabalho para ele, ou como parte de um thread existente, caso em que ele procura o item de trabalho existente e acrescenta a parte específica do segmento de mensagem de email para o histórico de revisão de itens de trabalho. Exchange expõe a parte de um e-mail que é específico para o email atual no segmento por meio da propriedade UniqueBody de EmailMessage. Para obter o segmento completo, a propriedade corpo pode ser usada. Isso é muito sofisticado, pois ele permite a criação de encadeamento de e-mails no histórico de revisão do item de trabalho, como mostrado na a Figura 11.

Um caso especial que vale a pena mencionar é quando um email chega que faz parte de um thread, mas nenhum item de trabalho correspondentes disponível para atualizar. Isso normalmente acontece se o thread foi iniciado antes que o sistema de tickets foi colocado no lugar. Nesse caso, um novo item de trabalho é criado.

Em ordem para o serviço da Web determinar se um email já existe como um item de trabalho, ele se baseia em um pedaço de informação que ele armazena o item de trabalho quando o item de trabalho é criado: ConversationIndex. As consultas do serviço da Web funcionam itens com base nesse valor para descobrir se existe o item de trabalho. A consulta é executada usando a linguagem de consulta de item de trabalho da TFS (WIQL), como no código a seguir:

private const string QUERY_BY_CONVERSATION_INDEX_WIQL =
  "SELECT [System.Id] FROM WorkItems WHERE [System.TeamProject] = '{0}'  AND
    [System.WorkItemType] = 'Support Request' AND
    [MsdnMag.SupportTicket.ConversationIndex] = '{1}' ORDER BY [System.Id] desc";

WIQL fornece uma maneira fácil, embora poderosa para consultar um item de trabalho sem precisar carregar objetos e enumerar através de coleções.

O serviço da Web também fornece uma maneira para controlar facilmente nos logs de atividade do TFS. Os logs de atividade do TFS são armazenados em duas tabelas de SQL Server (tbl_Command e tbl_Parameter) no banco de dados para a coleção de projeto de equipe. Verificando a coluna UserAgent permite tbl_Command, os administradores do TFS descobrir a origem de solicitações.

A notificação de serviço da Web personaliza os dados de agente do usuário para identificar claramente usando a instrução a seguir:

TfsConnection.ApplicationName = string.Format(
  TFS_APPLICATIONNAME_TEMPLATE, WindowsIdentity.GetCurrent().Name);

Nesse caso específico, o agente do usuário será algo parecido com "msdnmagsubscribesvc – contoso\jdoe".

Outro recurso potencialmente útil do ConvertEmailToRequestItem é sua capacidade de filtrar emails de acordo com o prefixo na linha de assunto, como no código a seguir:

// First check if prefix-based filtering is turned on, and if so, 
// if the e-mail subject line matches the defined prefix.
string subjectPrefix = 
  ConfigurationManager.AppSettings["SubjectPrefix"];
if (!string.IsNullOrWhiteSpace(subjectPrefix))
{
  if (!title.StartsWith(subjectPrefix, 
    StringComparison.InvariantCultureIgnoreCase))
  {
    WriteEventToLog(
      string.Format(SUBJECT_DOES_NOT_MATCH_PREFIX_TEMPLATE,
      subjectPrefix, title));
 
    return;
  }
}

Você pode usar esse recurso para restringir a funcionalidade do serviço para apenas alguns emails; Por exemplo, para e-mails de revisão de código onde o prefixo pode ser definido como "Revisão do código".

Outros casos de uso: Revisões de código

O caso de uso apresentado aqui é um tíquete de suporte. No entanto, a flexibilidade da abordagem apresentada neste artigo torna mais fácil aplicar as mesmas técnicas para outros casos de uso, como, por exemplo, as revisões de código de rastreamento. O fluxo de processo para o caso de uso de revisão de código é representado no a Figura 14.

Process Flow for the Code Review Work Item

Figura 14 o fluxo de processo para o Item de trabalho de revisão de código

As organizações de desenvolvimento costumam realizar revisões de código via email. Houve muitas tentativas para integrar as revisões de código TFS criando itens de trabalho de revisão de código e a criação de suplementos para permitir que o processo de revisão de código de dentro de Visual Studio de gerenciamento. No entanto, a mesma técnica empregada para tíquetes de suporte pode fornecer uma maneira fácil de integrar a segmentos de email de revisão de código no sistema de acompanhamento do item de trabalho do TFS. As seguintes etapas descrevem um processo sugerido para usar a infra-estrutura de notificações com revisões de código:

  • Comece criando um item de trabalho de revisão de código semelhante para o item de trabalho de solicitação de suporte.
  • Defina uma conta watcher DL monitorar e-mails enviados para a lista de distribuição.
  • Use o recurso de SubjectPrefix, apresentado anteriormente para definir um prefixo que distingue os e-mails como e-mails de revisão de código. Solicitações de revisão de código enviadas via email, geralmente têm a linha de assunto segue este padrão: "revisão do código: meu nome Shelveset.”

Conforme mostrado na a Figura 14, associando-se o check-in real do conteúdo shelveset o item de trabalho fornece a capacidade de rastreamento em tempo de vida do código do quando o código foi feito, quando ele foi enviado para revisão de código, quando ele foi aprovado para check-in e, finalmente, quando foi feito check-in. Essa associação é um recurso poderoso do TFS oferece excelente visibilidade de qualquer código que obtém check-in por meio do controle de origem. É um ativo especialmente útil para organizações que exigem a rastreabilidade por motivos de auditoria.

Qual o próximo passo

O objetivo principal deste artigo foi demonstrar uma das muitas possibilidades de uso do TFS e Exchange juntos para aumentar a produtividade e a eficiência. Uma das excelentes coisas sobre itens de trabalho, especialmente em 2010 do TFS, é como estão integrados dentro do TFS. Itens de trabalho podem ser vinculados a conjuntos de alterações. Eles podem representar e controlar os planos de teste. Eles podem ser facilmente informados, usando o Excel ou SSRS, e também podem ser sincronizados com o Microsoft Project.

Armado com o caso de uso e as técnicas apresentadas neste artigo, você deve ser capaz de aproveitar o serviço da Web de notificações e as personalizações de item de trabalho em muitas situações específicas a seu próprio ambiente.

Mohammad Jalloul é engenheiro de software, Inc. o Myspace, um site de entretenimento social onde é responsável por integrar os processos de negócios diferentes o TFS e aproveitando-o para aumentar a eficiência e produtividade. Antes disso, ele trabalhou em Redmond na divisão de desenvolvedores da Microsoft em uma ferramenta interna chamada Gibraltar. Ele pode ser contatado por meio de seu blog em mohammadjalloul.com.

Graças aos seguinte técnico especialista para revisar este artigo: Bill Heys