Team foundation server - exploiter la partie cliente.

Soyez le premier à donner votre avis sur cette source.

Vue 5 758 fois - Téléchargée 181 fois

Description

Il s'agit d'une source sortie du placard et remise à jour que je vous présente.
Cette source montre comment utiliser en tant que client Team Foundation.
Cette démo met en avant plusieurs points comme l'authentification, la lecture des projets, le contrôle de versionning, l'exploration de version spécifique avec son téléchargement.

+ L'utilisation de linq est présente ce qui facilite les interrogations avec le serveur de controle de versionning.
+ La partie zip se fait avec la lib SharpZipLib (http://www.icsharpcode.net/OpenSource/SharpZipLib)
+ Le code principale est donné ci-dessous.
+ La source est commentée.

Source / Exemple :


using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using Microsoft.TeamFoundation.Client;
using Microsoft.TeamFoundation.VersionControl.Client;
using Microsoft.TeamFoundation.WorkItemTracking.Client;
using ICSharpCode.SharpZipLib.Zip;

namespace TFSDownload
{
    /// <summary>
    /// Simple classe permettant de voir quelques fonctionnalités clientes de Team Foundation.
    /// </summary>
    public class TfsSolution
    {
        TeamFoundationServer _tfs;
        NetworkCredential _credential;
        WorkItemStore _wrkItemsStore;
        VersionControlServer _verCtrlSrv;
        TeamProject _tp;
        System.Collections.IEnumerable _resultHistory;
        IEnumerable<Changeset> _resultSpecVersion;

        public delegate void DownloadEventHandler(string path, int n, int t);
        public delegate void CompressEventHandler(bool compressing);

        public event DownloadEventHandler Downloading;
        public event CompressEventHandler Compress;

        /// <summary>
        /// Indique si nous sommes authentifé.
        /// </summary>
        public bool IsAuthenticated
        {
            get { return _tfs.HasAuthenticated; }
        }

        /// <summary>
        /// Définit le credential pour l'authentification sur le serveur.
        /// </summary>
        /// <param name="userName">Nom d'utilisateur.</param>
        /// <param name="password">Mot de passe.</param>
        /// <param name="domain">Domaine.</param>
        public void SetCredential(string userName, string password, string domain)
        {
            _credential = new NetworkCredential(userName, password, domain);
        }

        /// <summary>
        /// S'authentifie sur le serveur.
        /// </summary>
        /// <param name="ServerUrl">Url du serveur TFS (ex: http://monServeur:8080).</param>
        public void Authenticate(Uri ServerUrl)
        {
            if (_tfs == null && _credential != null)
            {
                _tfs = new TeamFoundationServer(ServerUrl.AbsoluteUri, _credential);
                _tfs.Authenticate();
            }
        }

        /// <summary>
        /// Récupère les noms des projets d'équipes existant.
        /// </summary>
        /// <returns></returns>
        public string[] GetTeamProjectsName()
        {
            if (_tfs != null && this.IsAuthenticated)
            {
                List<string> projects = new List<string>();

                _wrkItemsStore = (WorkItemStore)_tfs.GetService(typeof(WorkItemStore));
                foreach (Project project in _wrkItemsStore.Projects)
                {
                    projects.Add(project.Name);
                }
                return projects.ToArray();
            }
            return null;
        }

        /// <summary>
        /// Récupère le service du controle de versionning.
        /// </summary>
        public void GetVersionControlServerService()
        {
            _verCtrlSrv = (VersionControlServer)_tfs.GetService(typeof(VersionControlServer));
        }

        /// <summary>
        /// Sélectionne un projet d'équipe.
        /// </summary>
        /// <param name="project">Nom du projet.</param>
        public void SelectTeamProject(string project)
        {
            _tp = _verCtrlSrv.GetTeamProject(project);
        }

        /// <summary>
        /// Lecture de l'arborescense d'une version spécifique définit par <paramref name="changeId"/> d'un projet
        /// sélectionné avec <see cref="SelectTeamProject"/>.
        /// </summary>
        /// <param name="changeId">ID d'un ensemble de modification.</param>
        /// <returns>Un dictionnaire<répertoire,liste<élements maj>>.</élements></returns>
        public Dictionary<string, List<Item>> ShowTeamProjectTree(int changeId)
        {
            Dictionary<string, List<Item>> trees = new Dictionary<string, List<Item>>();
            trees.Add(_tp.ServerItem, new List<Item>());

            //Vérifie qu'un projet a été sélectionné et que le service de controle de version est ok.
            if (_tp != null && _verCtrlSrv != null)
            {
                //Interroge le service de controle de version et récupère l'ensemble des modifs suivant son Id.
                _resultSpecVersion = _resultHistory.OfType<Changeset>().Where(v => v.ChangesetId == changeId);
                foreach (Changeset cs in _resultSpecVersion)
                {
                    //Si des changements trouvés...
                    if (cs.Changes.Length > 0)
                    {
                        //...Parcourt l'ensemble et l'inscrit dans le dictionnaire d'arborescense.
                        foreach (Change c in cs.Changes)
                        {
                            if (c.Item.ItemType == ItemType.Folder)
                            {
                                if (!trees.ContainsKey(c.Item.ServerItem))
                                    trees.Add(c.Item.ServerItem, new List<Item>());
                            }
                            else if (c.Item.ItemType == ItemType.File)
                            {
                                string szBasePath = c.Item.ServerItem.Substring(0, c.Item.ServerItem.LastIndexOf("/"));
                                if (!trees.ContainsKey(szBasePath))
                                    trees.Add(szBasePath, new List<Item>());

                                trees[szBasePath].Add(c.Item);
                            }
                        }

                    }
                }
            }

            return trees;
        }

        /// <summary>
        /// Permet d'obtenir la liste des versions d'un projet sélectionné avec <paramref name="SelectTeamProject"/>.
        /// </summary>
        /// <returns></returns>
        public List<ProjectVersionInfo> GetProjectVersions()
        {
            List<ProjectVersionInfo> vers = new List<ProjectVersionInfo>();

            if (_tp != null && _verCtrlSrv != null)
            {
                //Interroge le service de controle de version...
                _resultHistory = _verCtrlSrv.QueryHistory(_tp.ServerItem, VersionSpec.Latest, 0, RecursionType.Full, null,
                    null, null, int.MaxValue, true, true);

                //Récupère les versions.
                foreach (Changeset item in _resultHistory)
                {
                    vers.Add(
                        new ProjectVersionInfo(item.ChangesetId, item.CreationDate, item.Owner, item.Comment)
                        );
                }
            }

            return vers;
        }

        /// <summary>
        /// Télécharge une version spécifique d'un projet et l'archive au fichier zip.
        /// </summary>
        /// <param name="changeId">Id d'un ensemble de modifation.</param>
        /// <param name="outputZip">Fichier zip de sortie.</param>
        public void DownloadSpecificVersion(int changeId, string outputZip)
        {
            string szTmpPath = outputZip.Substring(0, outputZip.LastIndexOf(@"\"));

            if (!Directory.Exists(szTmpPath))
                Directory.CreateDirectory(szTmpPath);

            //Vérifie qu'un projet a été sélectionné et que le service de controle de version est ok.
            if (_tp != null && _verCtrlSrv != null)
            {
                Directory.CreateDirectory(Path.Combine(szTmpPath, _tp.ServerItem.Replace(@"/", string.Empty)));

                //Interroge le service de controle de version et récupère l'ensemble des modifs suivant son Id.
                _resultSpecVersion = _resultHistory.OfType<Changeset>().Where(v => v.ChangesetId == changeId);
                foreach (Changeset cs in _resultSpecVersion)
                {
                    //Téléchargement des fichiers...
                    if (cs.Changes.Length > 0)
                    {
                        int count = 1;
                        foreach (Change c in cs.Changes)
                        {
                            if (Downloading != null)
                                Downloading(c.Item.ServerItem, count, cs.Changes.Length);

                            string szpath = Path.Combine(szTmpPath, c.Item.ServerItem.Remove(1, 1).Replace(@"/", @"\"));

                            if (c.Item.ItemType == ItemType.Folder)
                            {
                                if (!Directory.Exists(szpath))
                                    Directory.CreateDirectory(szpath);
                            }
                            else if (c.Item.ItemType == ItemType.File)
                            {
                                string szBasePath = szpath.Substring(0, szpath.LastIndexOf(@"\"));
                                if (!Directory.Exists(szBasePath))
                                    Directory.CreateDirectory(szBasePath);

                                c.Item.DownloadFile(szpath);
                            }

                            count++;
                        }

                        if (Compress != null)
                            Compress(true);

                        //Zip du répertoire tampon.
                        string szSourcePath = Path.Combine(szTmpPath, _tp.ServerItem.Replace(@"/", string.Empty));
                        ZipFolder(szSourcePath, outputZip, true);

                        if (Compress != null)
                            Compress(false);

                        //Suppression du répertoire tampon.
                        try
                        {
                            Directory.Delete(szSourcePath, true);
                        }
                        catch (Exception) { }
                    }
                }
            }
        }

        //Déconnecte du serveur.
        public void Close()
        {
            if (_tfs != null)
            {
                _tfs.Dispose();
            }
        }

        /// <summary>
        /// Archive un dossier.
        /// </summary>
        /// <param name="source"></param>
        /// <param name="zipFilename"></param>
        /// <param name="recursive"></param>
        void ZipFolder(string source, string zipFilename, bool recursive)
        {
            FastZip ZipOut = new FastZip();
            ZipOut.CreateZip(zipFilename, source, recursive, "");
        }
    }
}

Conclusion :


Bon dév ;)
Si vous avez des questions ne pas hésiter.

Codes Sources

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.