Cet article a fait l'objet d'une traduction automatique.

Team Foundation Server et Exchange

Concevoir un système de création de tickets à l'aide d'Exchange et de Team Foundation Server

Mohammad Jalloul

Télécharger l'exemple de code

Team Foundation Server (TFS) fournit un mécanisme formidable permettant de créer et de gestion des tickets par l'intermédiaire de son élément de travail puissante fonction de suivi. Ce suivi est généralement effectuée de deux façons. Dans le premier, un représentant du support technique d'accéder à TFS via son interface Web (également appelé Team System Web Access, ou TSWA) crée un type d'élément de travail personnalisé pour obtenir un ticket de prise en charge, entrez les détails nécessaires. Dans la deuxième méthode, une interface est créée pour habiller la fonctionnalité d'élément de travail et simplifier l'accès à celui-ci pour les utilisateurs externes qui n'est pas nécessaire de savoir sur TFS. L'élément de travail est ensuite généralement attribué à un ingénieur logiciel qui effectue le suivi et gère l'élément de travail à partir de Visual Studio. L'objectif de ces deux méthodes consiste à déplacer création du ticket de courrier électronique ou de systèmes de base de données propriétaire pour TFS en raison de ses nombreux avantages — en particulier de travail TFS éléments ont un flux de travail qui définit le cycle de vie d'un ticket. Toute personne peut conserver le suivi d'un ticket en surveillance des modifications à l'élément de travail et l'affichage de l'historique des éléments de travail. Intégration avec l'entrepôt de données TFS présente un avantage supplémentaire, comme vous pouvez tirer parti des puissantes fonctionnalités de rapport de SQL Server Reporting Services (SSRS) ou Excel Services.

En dépit de ces méthodes, e-mails souvent obtenir envoyés autour de même, pour décrire le problème davantage ou pour ajouter plus de détails. Ces informations de thread de messagerie supplémentaires sont parfois perdues, et parfois copié manuellement dans l'historique des éléments de travail pour conserver le cadre de l'élément de travail aussi complète que possible. Cette intervention manuelle nuit à l'utilité des éléments de travail et peut arrêter la productivité qu'éléments ont été conçus pour fournir le travail.

Je vais présenter une troisième méthode dans cet article utilise le meilleur des deux mondes : envoyer par courrier électronique et d'éléments de travail. Cette approche commence par courrier électronique, tout comme la prise en charge de vous-même les représentants pendant une longue période.

Services Web Exchange

Le processus que je vais présenter utilise la puissance de Microsoft Exchange Web Services (EWS) pour vous abonner aux notifications pour les courriers électroniques envoyés à une liste de distribution Exchange 2007/2010. Le service d'écoute Web crée un élément de travail basé sur tout nouveau message électronique reçu. Les e-mails suivants liés à la même thread sont ajoutées à l'historique d'élément de travail, en utilisant les fonctionnalités de suivi de la conversation du Microsoft Exchange Server, donc la thread de message électronique dans l'élément de travail de la mise en miroir. L'élément de travail gère également un flux de travail. De cette façon les utilisateurs, les représentants de la prise en charge — ne modifient pas leurs habitudes de s'adapter à une nouvelle technologie ; au lieu de cela, la technologie est tenu de leurs processus et en automatisant il.

Figure 1 montre comment le processus iront en général.

Figure 1 des flux de processus pour l'élément de travail de Ticket de prise en charge

La section suivante présente le flux de façon plus détaillée :

1. Le flux démarre lorsqu'un technicien du support est averti d'un problème avec un produit.
2. Le technicien envoie un message électronique décrivant le problème à une liste de distribution (DL) dans Exchange. La liste de distribution comprend tous ceux qui ont besoin de savoir sur le problème et vous pouvez l'affecter au développeur approprié pour le résoudre. La liste de distribution contient également un compte de messagerie « Observateur » qui existe uniquement à des fins de notification. Le compte de l'Observateur est enregistré avec Exchange afin qu'il recevra des notifications à une adresse de service Web spécifique.
3. Exchange traite le courrier électronique, le routage vers tous les membres de la liste de distribution et l'envoi de notifications à tous les services Web qui sont inscrits pour recevoir les pour un compte de messagerie spécifiée.
4. Le ticket de prise en charge du service Web reçoit une notification à partir d'Exchange via son interface de service Web.
5. Le service Web traite la notification et demande des informations supplémentaires relatives à l'adresse de messagerie. Il crée ensuite un élément de travail demande de Support dans le serveur TFS, qui est rempli avec les informations extraites du message électronique.
6. Les membres de la liste de distribution reçoivent également le courrier électronique et ils peuvent répondre en demandant des informations complémentaires, qui envoie le représentant de la prise en charge. Étant donné que la liste de distribution est inclus dans le champ à ou CC champs du message électronique, le compte de messagerie de l'Observateur est conscient de ce document et le service Web de notifications reçoit des notifications de tous les e-mails qui passe dans le thread. TFS met à jour l'élément de travail demande de Support avec les informations supplémentaires.
7. Le ticket est attribué à un développeur qui utilise le champ assigné à de la demande de Support d'élément de travail seulement créé.
8. Le développeur démarre collaboré sur un problème, modifiez l'état de l'élément de travail en cours. Lorsque le code contenant le correctif est révisé, testé et terminé, il sera archivé. L'ensemble de modifications qui en résulte est associé à l'élément de travail demande de Support. Cet élément de travail suit maintenant la conversation de messagerie et de l'ensemble de modifications liées à la correction.
9. Si le technicien peut accéder à TFS, la demande de Support peut être qui lui sont confiées de fermeture. Dans le cas contraire, la liste de distribution peut être averti par courrier électronique. En règle générale, prospects et les chefs de projets va configurer des alertes de TFS afin qu'ils avertir l'utilisateur lorsqu'un élément de travail demande de Support a été résolu. Ceci a lieu lorsque l'élément de travail passe d'en cours à terminé.

Le processus est en fait similaire à ce qui a généralement lieu dans les scénarios réels impliquant des problèmes de support — sauf, dans la réalité, le thread de courrier électronique et système de gestion des tickets sont généralement deux systèmes distincts et complètement différents.

Le Service Web de Ticket de prise en charge des Notifications

Le service de Support Ticket Notifications Web utilise l'EWS Managed API, qui vous permet de gérés.NET de communiquer avec EWS à l'aide d'interfaces documentées via la messagerie basés sur SOAP familier. Vous trouverez une description détaillée de l'API de gestion EWS à bit.ly/jGKRgG.

EWS ne fait pas partie typique d'une installation de Microsoft Exchange, et dans de nombreuses configurations informatiques, il est installé sur un serveur d'accès Client Exchange distinct. Pour être utilisable, les services doivent être installés et configurés avec Microsoft Exchange. Vous devez obtenir l'URL du service Web EWS à partir de vos administrateurs Exchange, qui ressemblera à https://nom d'hôte/EWS/Exchange.asmx. Notez que ces services Web sont généralement définis sur un point de terminaison SSL.

La dernière version de l'API de gestion EWS au moment de cette écriture est la 1.1. Cette version prend en charge Microsoft Exchange Server 2007 SP1 via Exchange Server 2010 SP1. Vous pouvez le télécharger à partir de bit.ly/mkb7Is.

Par défaut, le programme d'installation copie les fichiers dans [Program Files] \Microsoft\Exchange\Web Services\1.1. L'API est présente dans un seul assembly nommé 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.

La première étape de l'interaction avec EWS consiste à créer un service Web pour écouter les notifications en provenance d'Exchange. Une fois que ce service Web est créé, il doit être enregistré avec Exchange pour recevoir des notifications.

Le SDK Microsoft Exchange Server 2010 SP1 Web Services simplifie la création de ces services Web. Vous pouvez télécharger la version d'octobre 2010 (la dernière version au moment de la rédaction) à bit.ly/kZtjLq.

Le SDK facilite beaucoup plus facile créer le premier service Web. Il contient quatre échantillons qui explorent des différentes zones ciblées par l'API. Vous pouvez accéder aux exemples après avoir installé le Kit de développement en accédant au menu Démarrer | Tous les programmes | Exchange Server SDK des Services Web SP1 2010 | Octobre 2010 | Exchange Server le répertoire d'exemples 2010 SP1 Web Services SDK. L'exemple qui est particulièrement intéressante est PushNotification, qui illustre un service Web notifications push qui écoute et traite les notifications entrantes à partir d'Exchange. Cet exemple contient également une application cliente, que vous pouvez utiliser pour créer un abonnement en échange de service Web. L'utilisation de cet exemple comme une implémentation de base rend facile à comprendre la façon EWS works et pour vérifier que tous les éléments requis sont fonctionnels.

Abonnement avec Exchange

Vous aurez besoin d'un compte Exchange pour créer un abonnement de notifications avec Exchange. L'abonnement va configurer le routage de sorte que les courriers électroniques envoyés à boîte aux lettres de ce compte entraînera dans Exchange qui effectue un appel au service de notifications enregistrés pour ce compte. Notez qu'il est possible d'enregistrer plusieurs notifications pour tous les comptes. En fait, il est même possible de créer plus d'un abonnement pour le même point de terminaison de service Web. À partir d'un point de vue Exchange et EWS, c'est parfaitement légitime.

La seule exigence pour les services Web enregistrée avec EWS est qu'ils implémentent une interface spécifique, INotificationServiceBinding, qui possède la signature suivante :

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

La seule exigence est que le service Web contient une implémentation de la méthode SendNotification. Il s'agit de la méthode Web qui sera appelée par Exchange chaque fois qu'un message électronique mise en correspondance les attributs d'abonnement est reçu.

Retour à l'exemple de PushNotification et, en particulier, l'application de console PushNotificationSubscriber, il devient évident qu'implique un abonnement. Figure 2 indique la méthode de SubscribeForPushNotification provenant du fichier PushNotificationSubscriber.cs.

Figure 2 Code d'abonnement à partir de l'exemple 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);

}

J'ai inclus le code dans Figure 2 ici les car il illustre la clé de fonctionnalités disponibles lors de l'enregistrement d'un abonnement. En particulier, notez comment l'exemple attribue le premier élément d'information, l'URL de serveur d'accès Client :

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

Il utilise ensuite les informations d'identification du compte de messagerie pour s'authentifier avec EWS :

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

Notez également que dès que vous avez créé un objet d'abonnement, vous pouvez le configurer afin qu'il s'abonne uniquement à certains événements (nouveaux messages, copie, déplacement, suppression, modification, etc.) ou aux dossiers de messagerie spécifique. Cela fournit une grande souplesse, comme vous pouvez déléguer le filtrage à Exchange plutôt que de s'abonner à tous les événements et filtrage dans l'application ultérieurement.

Enfin, notez la propriété StatusFrequency. Il s'agit d'une valeur numérique qui définit, en minutes, la fréquence à laquelle Exchange envoie des pulsations des appels au service Web pour vous assurer que le point de terminaison inscrit est actif. Cela permet d'annuler les abonnements à des points de terminaison qui ne sont plus valides, tels que pour un service Web qui est déplacé vers un nouvel hôte et a donc une nouvelle URL Exchange. Si vous oubliez d'annuler votre abonnement avant de déplacer le service Web, l'abonnement peut durer indéfiniment, et Exchange devrait conserver envoi de notifications inutilement à un point de terminaison qui n'existe pas.

Maintenant Examinons l'implémentation personnalisée pour prendre en charge la création d'éléments de travail TFS de la demande prend en charge. La meilleure façon de présenter la fonctionnalité doit commencer par une démonstration du service Web et avant d'étudier la mise en oeuvre.

Déploiement du service Web

Le projet de code qui accompagne cet article contient uniquement un service Web et plusieurs autres artefacts prise en charge. Il n'y a aucune application de console distincte pour prendre en charge de l'enregistrement car il est intégré au service Web.

Une fois créé, le service Web peut être déployé à partir de 2010 de Visual Studio ou en copiant le site Web précompilé qui en résulte à un hôte. Vous devrez créer manuellement l'application Web et un pool d'applications correspondant. Définissez l'identité du pool d'applications pour le compte d'utilisateur de l'Observateur. Ceci est important car le service Web peut emprunter l'identité de pool d'applications et de l'utiliser pour effectuer l'abonnement. Cette méthode présente deux avantages :

1. Les informations d'identification ne doivent être entrées à nouveau chaque fois que le service Web doit être réinscrit.
2. Les informations d'identification ne doivent être stockés dans lequel ils peuvent être accessibles afin de les utiliser pour réabonner.

Le service Web doit disposer des autorisations en écriture pour deux dossiers : le dossier dans lequel il écrit des journaux et le dossier qu'il utilise en tant que le cache TFS. En outre, vous devez configurer les paramètres suivants dans le fichier web.config, que ceux-ci dépendent de l'environnement particulier où le service Web est utilisé :

• EWSServiceUrl: L'échange URL du Service ; les administrateurs Exchange obtenir cette URL..
• TeamFoundationServerUrl: L'URL de la TFS collection où sont déployés les éléments de travail de projet (par exemple :http://<servername>:8080/tfs/).
• WorkItemTeamProject: Le nom du projet d'équipe TFS qui contient le ticket de prise en charge des éléments de travail type (par exemple :SupportWorkFlow).
• WorkItemType:Le nom réel du ticket de prise en charge des éléments de travail type (par exemple : demande de Support). Si l'élément de travail est renommé ou si le Web service est utilisé pour prendre en charge un autre élément de travail tapez (comme indiqué plus loin dans cet article), vous pouvez utiliser cela pour définir le nom du nouvel élément de travail.
• RequestSupportTeamName: L'élément de travail contient un champ de « Demander équipe chargée de prendre en charge » permettant de diriger les équipes différentes de prise en charge différentes tâches. Il est piloté par une liste globale appelée équipes dans la définition d'élément de travail. Pour utiliser cette fonctionnalité, conserver la définition de champ et créer la liste globale (instructions sont incluses dans la section suivante du présent article, « Configuration de l'élément de travail ») et assignez l'une des valeurs de la liste globale à la clé de configuration RequestSupportTeamName (par exemple : Service clientèle). Si ce n'est pas le cas, supprimez la liste globale pour le champ et la contrainte « Obligatoire » à partir de l'élément de travail et ne renseignez pas la valeur de la clé RequestSupportTeamName.

À ce stade, le service Web est prêt à être utilisé. Vous pouvez vérifier qu'il est configuré correctement l'aide du Gestionnaire IIS sur le serveur Web pour naviguer vers le dossier d'application Web (n'oubliez pas de cliquer sur l'onglet Affichage du contenu dans le bas si vous utilisez IIS 7 ou version ultérieure). Ensuite avec le bouton droit sur le fichier Service.asmx et cliquez sur Parcourir, comme illustré à la Figure 3. Vous devriez voir une page Web identique à celle de la Figure 4.

Figure 3 accédant à la Page ASMX

Figure 4 Par défaut l'URL du Service Web avec localhost que l'hôte

Avant de pouvoir commencer à l'aide du service Web, vous devez importer l'élément de travail TFS. Cet article suppose que vous utilisez TFS 2010, mais le même élément de travail et le service Web peuvent être utilisés avec TFS 2008.

Configuration de l'élément de travail

L'exemple de code pour cet article (que vous pouvez télécharger à code.msdn.microsoft.com/mag201108TFS) contient un exemple support ticket work item type appelé demande de Support. Afin d'afficher la définition de type élément de travail, le flux de travail et la disposition avant d'importer des données dans TFS, vous devez installer TFS Power Tools, disponible à l'adresse bit.ly/hyUNqo. Lorsque vous installez TFS Power Tools, un nouveau menu appelé éditeur de processus est ajouté à l'IDE de Visual Studio dans le menu Outils. Double-cliquez sur la prise en charge Request.xml (situé sous le dossier de l'élément de travail dans la solution d'échantillon). The Work Item Editor window will be loaded with three tabs: Fields, Layout and Workflow, as shown in Figure 5.

(cliquez pour agrandir)

Figure 5 flux de travail pour l'élément de travail de Ticket de prise en charge

Flux de travail de l'élément de travail présente les différents États qui prend en charge de l'élément de travail : nouveau, lorsque l'élément de travail est tout d'abord créé ; En cours, lorsque le problème est documenté dans l'élément de travail est réellement cours ; et fait, lorsque le travail sur le problème conclut.

Si vous décidez de configurer le champ demander une équipe de Support, comme indiqué plus haut, recherchez le champ demander une équipe de Support sous l'onglet champs, double-cliquez dessus pour ouvrir la boîte de dialogue Définition de champ et puis cliquez sur l'onglet règles. Si vous ne prévoyez pas sur l'utilisation de ce champ, supprimez simplement les deux règles répertoriés (ALLOWEDVALUES et REQUIRED). Si vous ne souhaitez pas utiliser le champ mais que vous souhaitez configurer pour utiliser une autre liste globale, double-cliquez sur la règle ALLOWEDVALUES, puis sur la seule entrée présente : GLOBALLIST : les équipes. Dans la boîte de dialogue Modifier des éléments de liste, choisissez une liste globale et cliquez sur OK.

Si vous n'avez pas une liste globale encore configurée, vous pouvez créer un (vous devez disposer des autorisations administrateur TFS) :

1. Dans l'IDE de Visual Studio, cliquez sur Outils | Éditeur de processus | Liste globale et puis cliquez sur Ouvrir la liste globale du serveur.
2. Vous allez recevoir une boîte de dialogue. Sélectionnez la Collection de projet d'équipe, puis cliquez sur se connecter.
3. Dans la boîte de dialogue liste globale, avec le bouton droit sur n'importe quel élément et puis cliquez sur nouvelle liste globale.
4. Entrez un nom pour la liste globale. You can keep the same name as in the work item: Équipes.
5. Avec le bouton droit de la nouvelle liste globale, puis cliquez sur Nouvel élément. Répétez cette étape pour autant de fois que nécessaire pour entrer les noms de l'équipe.
6. Cliquez sur OK pour enregistrer la nouvelle liste globale.

Notez que si vous avez donné la nouvelle liste globale d'un nom différent, vous devrez modifier l'élément de travail et de mettre à jour de sa définition avec le nom de la liste globale.

À ce stade, tout ce qui reste consiste à importer de l'élément de travail dans TFS, comme suit :

1. Dans l'IDE de Visual Studio, cliquez sur Outils | Éditeur de processus | Types d'élément de travail et puis cliquez sur importation WIT (WIT béquille pour le Type d'élément de travail).
2. Cliquez sur le bouton Parcourir et naviguez jusqu'à l'emplacement du fichier Request.xml de prise en charge.
3. Dans le projet à importer dans la liste, cliquez sur le nom du projet d'équipe TFS dans lequel vous souhaitez importer l'élément de travail, puis cliquez sur OK.

Vous pouvez vérifier que l'élément de travail ont été importée avec succès dans TFS par clic droit sur le nœud éléments de travail pour ce projet d'équipe à partir de Team Explorer, puis en développant la fenêtre d'un élément de travail. Vous devriez voir la demande d'assistance parmi les options disponibles. Si vous ne le voyez, cliquez sur le nœud éléments de travail et puis cliquez sur Actualiser.

Création d'un abonnement

Comme indiqué dans Figure 4, le service Web a trois méthodes : vérifier l'état, SendNotification et s'abonner. La méthode Web s'abonner est utilisée pour créer les abonnements de notification.

Le processus d'abonnement crée une souscription pour le compte d'utilisateur qui est défini comme l'identité du Pool d'applications de service Web. Pour utiliser efficacement les notifications, qui compte — le compte de l'Observateur, doit faire partie d'une liste de distribution qui consiste à surveiller, comme dans Figure 6.

Figure 6 Ajouter le compte de messagerie de l'observateur à une liste de Distribution

Pour créer un abonnement, cliquez sur le lien s'abonner sur la page Web affichée dans Figure 4. Cliquez ensuite sur le bouton appeler sur la page Web résultante. Cas de réussite, vous verrez un ID d'abonnement. Cette opération est également enregistrée dans le dossier logs défini dans le fichier web.config.

Les détails de l'abonnement sont enregistrés en deux fichiers. Le premier connecte à la demande envoyée à EWS pour effectuer l'abonnement et a la forme SubscribeType-<timestamp> .xml. Le second fichier enregistre la réponse reçue de EWS pour confirmer l'abonnement et a la forme SubscribeResponseType-<timestamp> .xml. Un troisième fichier nommé SubscriberEventLog.txt enregistre tous les événements reçus par le service Web à partir d'Exchange, y compris un événement d'état de pulsation chaque minute et les événements de nouveaux messages chaque fois qu'elles sont déclenchées.

L'état de l'abonnement peut être vérifiée à tout moment en appelant la méthode CheckStatus Web, qui produit un résultat semblable à celle présentée dans Figure 7, qui indique l'heure du dernier événement de pulsation a été reçu et l'état de l'abonnement au service Web. If there’s an active subscription, you’ll see “Status: Subscribed,” as shown in the figure.

Figure 7 exemple de sortie de la méthode Web CheckStatus

Le processus général est représenté dans le diagramme de séquence dans Figure 8.

Figure 8 l'abonnement et le processus de Notification

En utilisant le système de gestion des tickets

Pour commencer à utiliser le système de gestion des tickets, la plus simple consiste à simuler un scénario réel et envoyer un e-mail à la liste de distribution qui contient le compte de l'Observateur. Figure 9 montre un exemple de courrier électronique à la liste de distribution illustré Figure 6, et Figure 10 indique l'élément de travail de demande d'assistance qui est généré à la suite de la notification envoyée à partir d'Exchange pour le service Web de notifications.

Figure 9 le premier message électronique dans un échange de courrier

(cliquez pour agrandir)

Figure 10 l'élément de travail généré à la suite de la messagerie de premier

Figure 11 affiche le résultat de l'envoi d'autres messages électroniques dans le cadre de la même thread de courrier électronique et comment qui est convertie en l'historique des éléments de travail. Le premier thread obtient une couleur distincte pour son en-tête. Le reste des threads d'obtenir une autre couleur distincte (dans ce cas de couleur jaune, mais les couleurs peuvent être configurés dans le fichier web.config).

(cliquez pour agrandir)

Figure 11 l'élément de travail après un deuxième message électronique

Personnalisation du Code

Maintenant nous allons étudier les différentes parties du code qui rendent le système fonctionne. L'exemple de code pour cet article contient une solution de Visual Studio 2010 appelée 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.

Pour l'essentiel, le service Web est basé sur l'échantillon SDK PushNotification. Toutefois, j'ai apporté des modifications afin de conserver la solution générique et facile à utiliser. J'ai passerez en revue les modifications et les personnalisations apportées à transformer l'échantillon en une solution de gestion des tickets.

Le premier changement majeur est la fonctionnalité qui permet le processus d'abonnement à être intégrées dans le service Web. Cela est essentiel car il permet au service Web pour vous abonner sans avoir à gérer les informations d'identification de compte. Parfois l'abonnement doit être renouvelé, tels que lorsque le serveur hébergeant le service Web subit certaines activités de maintenance, par exemple. Dans ce cas, les Pools d'application sont généralement arrêtés et Exchange annule les abonnements dans la mesure où l'événement de pulsation n'obtient aucune réponse. Le renouvellement automatique de l'abonnement est obtenu en appelant la méthode InitializeTimer dans le constructeur de service Web. InitializeTimer, illustré à la Figure 12, crée une minuterie avec un intervalle spécifié dans le fichier web.config. Cette minuterie est responsable de renouveler un abonnement après les interruptions de service, par exemple.

Figure 12 La méthode 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;
        }
      }
    }
}

Le deuxième changement important est d'inspecter le message entrant afin de déterminer s'il est le premier message électronique dans un thread. Figure 13 illustre cette fonctionnalité.

Figure 13 détermination le premier message électronique dans un 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);
}

Notez la façon dont le code s'appuie sur le fait que l'identité de Pool d'applications de service Web est ce qui peut être effectué sans avoir à entrer des informations d'identification de compte de messagerie, ce qui signifie que Web appelle pour récupérer les détails du message électronique.

La méthode ConvertEmailToRequestItem effectue le plus gros du travail. Pour déterminer si un message électronique est le premier message électronique ou partie d'un thread, il montre comment utiliser la ConversationIndex propriété de l'instance EmailMessage. La longueur du tableau 
byte ConversationIndex est 22 lorsqu'il est le premier message. Les e-mails dans un thread obtenir des octets ajoutés à la ConversationIndex supplémentaires. ConvertEmailToRequestItem utilise pour déterminer si pour traiter le courrier électronique comme un nouveau message et créer un nouvel élément de travail, ou dans le cadre d'un thread existant, auquel cas il recherche l'élément de travail existant et ajoute la partie spécifique de la thread du message électronique à l'historique de révision des élément de travail. Exchange expose la partie d'un message électronique qui est spécifique au courrier électronique en cours dans le thread via la propriété EmailMessage UniqueBody. Pour obtenir le thread complète, la propriété Body peut être utilisée. Ceci est un outil puissant, car elle permet de créer le thread de messagerie de l'historique de révision élément de travail, comme dans Figure 11.

Un cas spécial qui mérite est arrivée d'un message électronique qui fait partie d'un thread, mais avec aucun élément correspondant de travail disponible pour mettre à jour. Cela se produit généralement si le thread a démarré avant que le système de gestion des tickets a été mis en place. Dans ce cas, un nouvel élément de travail est créé.

Dans l'ordre pour le service Web déterminer si un message électronique existe déjà comme un élément de travail, il s'appuie sur un élément d'information, il stocke dans l'élément de travail lorsque vous créez l'élément de travail : ConversationIndex. Les requêtes de service Web éléments de travail basés sur cette valeur pour savoir si l'élément de travail existe. L'interrogation est effectuée en utilisant le langage de requête des éléments de travail TFS (langage WIQL), comme dans le code suivant :

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";

Langage WIQL vous offre un moyen simple et puissant pour interroger un élément de travail sans avoir à charger des objets et énumérer des collections.

Le service Web fournit également un moyen pour le retrouver facilement dans les journaux d'activité TFS. Les journaux d'activité TFS sont stockés dans deux tables de SQL Server (tbl_Command et tbl_Parameter) dans la base de données pour la collection de projet d'équipe. Inspection de la colonne UserAgent dans tbl_Command vous permet de TFS administrators figure l'origine des demandes.

La notification du service Web personnalise les données de l'agent utilisateur afin d'identifier clairement à l'aide de l'instruction suivante :

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

Dans ce cas particulier, l'agent utilisateur ressemblera à « msdnmagsubscribesvc – contoso\jdoe. »

Une autre fonctionnalité potentiellement utile de ConvertEmailToRequestItem est sa capacité à filtrer les e-mails en fonction de préfixe dans la ligne d'objet, comme dans le code suivant :

// 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;
  }
}

Vous pouvez utiliser cette fonctionnalité pour limiter les fonctionnalités du service à uniquement certains messages électroniques ; par exemple, pour les e-mails de révision de code où le préfixe peut être défini en tant que « Examen du Code ».

Other Use Cases: Révision de code

Le cas d'utilisation présenté ici est un ticket de prise en charge. Toutefois, la flexibilité de l'approche présentée dans cet article facilite appliquer les mêmes techniques pour les autres cas d'utilisation, telles que la révision des codes de suivi. Le flux de processus pour le cas d'utilisation de code révision est représenté dans Figure 14.

Figure 14 des flux de processus pour l'élément de travail Révision du Code

Les organisations de développement ont tendance à des révisions de code par courrier électronique. Grand nombre de tentatives pour intégrer des révisions de code TFS en créant des éléments de travail Révision du code et en créer des compléments pour permettre de gérer le processus de révision de code à partir de Visual Studio ont été. Toutefois, la même technique employée pour les tickets de support peut fournir un moyen facile d'intégrer des threads de messagerie électronique de révision de code dans l'élément de travail TFS système de suivi. Un processus suggéré pour l'utilisation de l'infrastructure des notifications avec les révisions de code ci-dessous.

• Commencez par créer un élément de travail Révision du Code semblable à l'élément de travail demande de Support.
• Configurer un compte de l'Observateur dans une liste de distribution pour analyser les courriers électroniques envoyés à la liste de distribution.
• Utilisez la fonctionnalité SubjectPrefix présentée précédemment pour définir un préfixe qui distingue les e-mails, les e-mails de révision de code. Code review requests sent via e-mail often have the subject line follow this pattern: “Code Review: My-Shelveset-Name.”

Comme indiqué dans Figure 14, associant le réel archiver du contenu du jeu de réservations à l'élément de travail fournit traçabilité dans la durée de vie du code à partir de quand le code a été fait, lorsqu'il a été envoyé pour révision du code, lorsqu'il a été agréé pour archiver et, enfin, lorsqu'il a été archivé. Cette association est une fonctionnalité puissante de TFS assurant une excellente visibilité sur n'importe quel code qui obtient intégré à partir de contrôle de code source. C'est un atout particulièrement utile pour les organisations qui requiert une traçabilité pour des raisons d'audit.

Que dois-je faire ensuite

L'objectif clé de cet article a été pour illustrer l'une des nombreuses possibilités pour l'utilisation de TFS et Exchange ensemble pour accroître la productivité et l'efficacité. L'un des grands avantages sur les éléments de travail, en particulier en 2010 de TFS, est comment ils sont intégrés à l'intérieur de TFS. Éléments de travail peuvent être liés à des ensembles de modifications. Ils peuvent représenter et effectuer le suivi des plans de test. Ils peuvent être facilement transmis, à l'aide d'Excel ou SSRS, et ils peuvent également être synchronisées avec Microsoft Project.

Grâce aux cas d'utilisation et les techniques présentées dans cet article, doit vous permettre d'exploiter le service Web de notifications et les personnalisations d'élément de travail dans de nombreux autres scénarios qui sont spécifiques à votre propre environnement.

Mohammad Jalloul est ingénieur logiciel Myspace Inc., un site Web de divertissement social où il est responsable de l'intégration de TFS dans les processus professionnels différents et exploitation de l'argent pour augmenter l'efficacité et la productivité. Au préalable, il a travaillé à Redmond dans la Division Developer chez Microsoft sur un outil interne appelé Gibraltar. Vous pouvez le contacter via son blog à mohammadjalloul.com.

Merci à l’expert technique suivant d’avoir relu cet article : Bill Heys