SprintDocumentation

Code Snippet
  1. using Microsoft.TeamFoundation.Client;
  2. using Microsoft.TeamFoundation.Framework.Client;
  3. using Microsoft.TeamFoundation.Framework.Common;
  4. using Microsoft.TeamFoundation.ProcessConfiguration.Client;
  5. using Microsoft.TeamFoundation.Server;
  6. using Microsoft.TeamFoundation.WorkItemTracking.Client;
  7. using RazorTemplateingSample.RazorTemplating;
  8. using System;
  9. using System.Collections.Generic;
  10. using System.Diagnostics;
  11. using System.IO;
  12. using System.Reflection;
  13. using System.Xml;
  15. namespace Centric.MVV.Tools.Reporting
  16. {
  17.     public class SprintDocumentation
  18.     {
  19.         private readonly TfsTeamProjectCollection tfsServer;
  21.         private readonly WorkItemStore tfsStore;
  23.         private readonly Project tfsSProject;
  25.         private TfsTeamService teamService;
  27.         private TswaClientHyperlinkService hyperLinkService;
  29.         private List<TeamFoundationTeam> allTeams;
  31.         public delegate void DoLog(String aMessage, bool isError);
  33.         public event DoLog Log;
  35.         private string templatesPath;
  37.         private void OnLog(String aMessage, bool isError)
  38.         {
  39.             if (Log != null)
  40.                 Log(aMessage, isError);
  41.         }
  43.         //public string[] ValidApplications { get; set; }
  45.         private IRazorTemplateGenerator generator;
  47.         public SprintDocumentation(string server, string project, string templatesPath)
  48.         {
  49.             tfsServer = new TfsTeamProjectCollection(new Uri(server));
  50.             tfsStore = (WorkItemStore)tfsServer.GetService(typeof(WorkItemStore));
  51.             tfsSProject = tfsStore.Projects[project];
  52.             hyperLinkService = tfsServer.GetService<TswaClientHyperlinkService>();
  53.             teamService = tfsServer.GetService<TfsTeamService>();
  54.             this.templatesPath = templatesPath;
  55.         }
  57.         public List<Team> GetTeams()
  58.         {
  59.             List<Team> teams = new List<Team>();
  60.             allTeams = teamService.QueryTeams(tfsSProject.Uri.AbsoluteUri) as List<TeamFoundationTeam>;
  61.             allTeams.ForEach(t => teams.Add(new Team { Name = t.Name }));
  62.             return teams;
  63.         }
  65.         public List<TeamMember> GetTeamMembers(string teamName)
  66.         {
  67.             List<TeamFoundationTeam> allTeams = teamService.QueryTeams(tfsSProject.Uri.AbsoluteUri) as List<TeamFoundationTeam>;
  68.             var team = allTeams.Find(t => t.Name.Contains(teamName));
  70.             TeamFoundationIdentity[] tfsMembers = team.GetMembers(tfsServer, MembershipQuery.Direct);
  71.             List<TeamMember> members = new List<TeamMember>();
  73.             for (int i = 0; i < tfsMembers.Length; i++)
  74.             {
  75.                 members.Add(new TeamMember { Name = tfsMembers[i].DisplayName });
  76.             }
  77.             return members;
  78.         }
  80.         public List<WorkItemInfo> GetIterationWorkItems(string iteration, bool getChildren)
  81.         {
  82.             var workItems = GetWorkItemInfoListForIteration(iteration);
  84.             List<WorkItemInfo> wis = new List<WorkItemInfo>();
  86.             for (int i = 0; i < workItems.Count; i++)
  87.             {
  88.                 WorkItem wi = workItems[i];
  90.                 WorkItemInfo wii = ProcessWorkItem(wi, getChildren);
  92.                 if (wii.Type != WorkItemType.Task)
  93.                 {
  94.                     wis.Add(wii);
  95.                 }
  96.             }
  97.             wis.Sort((x, y) => x.Priority.CompareTo(y.Priority));
  99.             return wis;
  100.         }
  102.         private WorkItemCollection GetWorkItemInfoListForIteration(string iterationPath)
  103.         {
  104.             string select = String.Format(„SELECT System.ID FROM workitems WHERE [Iteration Path] = ‘” + iterationPath + „‘”);
  105.             return tfsStore.Query(select);
  106.         }
  108.         private int ProcessWorkItemField(WorkItem wi, int fieldID, bool original, int defaultValue)
  109.         {
  110.             var field = wi.Fields.TryGetById(fieldID);
  111.             if (field != null)
  112.             {
  113.                 if (original)
  114.                 {
  115.                     return field.OriginalValue == null ? defaultValue : Int32.Parse(field.OriginalValue.ToString());
  116.                 }
  117.                 else
  118.                 {
  119.                     return field.Value == null ? defaultValue : Int32.Parse(field.Value.ToString());
  120.                 }
  121.             }
  122.             return defaultValue;
  123.         }
  125.         private string ProcessWorkItemField(WorkItem wi, int fieldID, bool original, string defaultValue)
  126.         {
  127.             var field = wi.Fields.TryGetById(fieldID);
  128.             if (field != null)
  129.             {
  130.                 if (original)
  131.                 {
  132.                     return field.OriginalValue == null ? defaultValue : field.OriginalValue.ToString();
  133.                 }
  134.                 else
  135.                 {
  136.                     return field.Value == null ? defaultValue : field.Value.ToString();
  137.                 }
  138.             }
  139.             return defaultValue;
  140.         }
  142.         private string GetWorkItemDescription(WorkItem wi, WorkItemType type)
  143.         {
  144.             string desc = String.Empty;
  145.             switch (type)
  146.             {
  147.                 case WorkItemType.Bug: desc = wi.Fields.TryGetById(10191).Value.ToString(); break;
  148.                 case WorkItemType.ChangeRequest: desc = wi.Fields.TryGetById(52).Value.ToString(); break;
  149.                 case WorkItemType.ProductBacklogItem:
  150.                 case WorkItemType.Task:
  151.                 case WorkItemType.TestCase:
  152.                 default: desc = wi.Fields.TryGetById(10212).Value.ToString(); break;
  153.             }
  154.             return desc;
  155.         }
  157.         private WorkItemInfo ProcessWorkItem(WorkItem wi, bool getChildren)
  158.         {
  159.             WorkItemInfo wii = new WorkItemInfo();
  160.             WorkItemType type = (WorkItemType)Enum.Parse(typeof(WorkItemType), wi.Type.Name.Replace(” „, String.Empty));
  162.             wii.ID = wi.Id;
  163.             wii.Type = type;
  164.             wii.TFSUrl = hyperLinkService.GetWorkItemEditorUrl(wii.ID).AbsoluteUri;
  165.             wii.Title = wi.Title;
  166.             wii.Description = GetWorkItemDescription(wi, type);
  167.             wii.CreatedBy = wi.CreatedBy;
  168.             wii.CreatedDate = wi.CreatedDate;
  169.             wii.AssignedTo = ProcessWorkItemField(wi, 24, false, String.Empty);
  171.             wii.Effort = ProcessWorkItemField(wi, 10213, false, 0);
  172.             wii.OriginalEffort = ProcessWorkItemField(wi, 10213, true, 0);
  173.             wii.Priority = ProcessWorkItemField(wi, 10211, false, 0);
  174.             wii.OriginalPriority = ProcessWorkItemField(wi, 10211, true, 0);
  175.             wii.AcceptanceCriteria = ProcessWorkItemField(wi, 10214, false, String.Empty);
  177.             wii.State = wi.State;
  179.             if (wi.Rev > 0)
  180.             {
  181.                 wii.WorkedOn = new List<string>();
  182.                 foreach (Revision revision in wi.Revisions)
  183.                 {
  184.                     string val = revision.Fields[„Assigned To”].Value.ToString();
  185.                     if (!String.IsNullOrEmpty(val) && !wii.WorkedOn.Contains(val))
  186.                     {
  187.                         wii.WorkedOn.Add(val);
  188.                     }
  189.                 }
  190.             }
  192.             if (getChildren)
  193.             {
  194.                 if (wi.WorkItemLinks.Count > 0)
  195.                 {
  196.                     wii.ChildWorkItems = new List<WorkItemInfo>();
  197.                 }
  198.                 foreach (WorkItemLink link in wi.WorkItemLinks)
  199.                 {
  200.                     if (link.BaseType == BaseLinkType.WorkItemLink && link.LinkTypeEnd.Name == „Child”)
  201.                     {
  202.                         WorkItem linkedWi = tfsStore.GetWorkItem(link.TargetId);
  203.                         wii.ChildWorkItems.Add(ProcessWorkItem(linkedWi, getChildren));
  204.                     }
  205.                 }
  206.             }
  208.             return wii;
  209.         }
  211.         public ProjectIterations GetAllIterations()
  212.         {
  213.             ProjectIterations result = new ProjectIterations();
  215.             var configSvc = tfsServer.GetService<TeamSettingsConfigurationService>();
  216.             var configs = configSvc.GetTeamConfigurationsForUser(new[] { tfsSProject.Uri.ToString() });
  218.             ICommonStructureService4 css = tfsServer.GetService<ICommonStructureService4>();
  220.             NodeInfo[] structures = css.ListStructures(tfsSProject.Uri.ToString());
  222.             NodeInfo iterations = structures[0];
  224.             XmlElement iterationTree = css.GetNodesXml(new[] { iterations.Uri }, true);
  226.             BuildIterations(iterationTree.ChildNodes, css, ref result);
  228.             result.Sort((x, y) => y.StartDate.Value.CompareTo(x.StartDate.Value));
  230.             return result;
  231.         }
  233.         private void BuildIterations(XmlNodeList iterationsTree, ICommonStructureService4 css, ref ProjectIterations iterations)
  234.         {
  235.             foreach (XmlNode item in iterationsTree)
  236.             {
  237.                 if (item.OuterXml.Contains(„YOUR_TEAM_NAME”))
  238.                 {
  239.                     var nodeId = GetNodeID(item.OuterXml);
  240.                     var nodeInfo = css.GetNode(nodeId);
  242.                     if (nodeInfo.StartDate != null && nodeInfo.FinishDate != null)
  243.                     {
  244.                         ProjectIteration pi = new ProjectIteration();
  245.                         pi.Name = nodeInfo.Name;
  246.                         pi.StartDate = nodeInfo.StartDate;
  247.                         pi.EndDate = nodeInfo.FinishDate;
  248.                         pi.IterationPath = nodeInfo.Path.Replace(„\\Iteration”, „”).TrimStart(‘\\’);
  250.                         iterations.Add(pi);
  251.                     }
  253.                     if (item.ChildNodes.Count > 0)
  254.                     {
  255.                         BuildIterations(item.ChildNodes, css, ref iterations);
  256.                     }
  257.                 }
  258.             }
  259.         }
  261.         private string GetNodeID(string xml)
  262.         {
  263.             var first = „NodeID=\””;
  264.             var start = xml.IndexOf(first) + first.Length;
  265.             var end = xml.IndexOf(„\””, start);
  266.             return xml.Substring(start, (end – start));
  267.         }
  269.         public List<string> GetTemplates()
  270.         {
  271.             List<string> templates = new List<string>();
  273.             FileInfo[] files = new DirectoryInfo(templatesPath).GetFiles(„*.html”);
  275.             foreach (FileInfo file in files)
  276.             {
  277.                 templates.Add(file.Name.Replace(„.html”, String.Empty));
  278.             }
  280.             return templates;
  281.         }
  283.         public void InitTemplates()
  284.         {
  285.             if (generator == null)
  286.             {
  287.                 generator = new RazorTemplateGenerator();
  289.                 FileInfo[] files = new DirectoryInfo(templatesPath).GetFiles(„*.html”);
  291.                 foreach (FileInfo file in files)
  292.                 {
  293.                     string t = file.OpenText().ReadToEnd();
  294.                     generator.RegisterTemplate<SprintDataModel>(file.Name.Replace(„.html”, String.Empty), t);
  295.                 }
  297.                 generator.CompileTemplates();
  298.             }
  299.         }
  301.         public string Generate(string template, SprintDataModel model)
  302.         {
  303.             InitTemplates();
  304.             return generator.GenerateOutput(model, template);
  305.         }
  306.     }
  307. }

One Reply to “SprintDocumentation”

  1. Pingback: How to connect to TFS from C# — Felix Vătuiu

Lasă un răspuns

Acest site folosește Akismet pentru a reduce spamul. Află cum sunt procesate datele comentariilor tale.