path: root/Software/Visual_Studio/Tango.TFS/TeamFoundationServiceClient.cs

using Microsoft.TeamFoundation.Client;
using Microsoft.TeamFoundation.Core.WebApi;
using Microsoft.TeamFoundation.WorkItemTracking.Client;
using Microsoft.TeamFoundation.WorkItemTracking.WebApi;
using Microsoft.VisualStudio.Services.Common;
using Microsoft.VisualStudio.Services.WebApi;
using Microsoft.VisualStudio.Services.WebApi.Patch;
using Microsoft.VisualStudio.Services.WebApi.Patch.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.Core;

namespace Tango.TFS
{
    /// <summary>
    /// Represents a VSTS (Visual Studio On-line) client implementation.
    /// </summary>
    /// <seealso cref="Tango.TFS.ITeamFoundationServiceClient" />
    public class TeamFoundationServiceClient : ExtendedObject, ITeamFoundationServiceClient
    {
        #region Extension Fields Constants

        private class ExtensionFields
        {
            public const String FOUND_IN_BUILD = "Microsoft.VSTS.Build.FoundIn";
            public const String SEVERITY = "Microsoft.VSTS.Common.Severity";
            public const String PRIORITY = "Microsoft.VSTS.Common.Priority";
            public const String STEPS_TO_REP = "Microsoft.VSTS.TCM.ReproSteps";
            public const String SYSTEM_INFO = "Microsoft.VSTS.TCM.SystemInfo";
        }

        #endregion

        #region Properties

        /// <summary>
        /// Gets the default team collection URL.
        /// </summary>
        public String CollectionURL { get; private set; }

        /// <summary>
        /// Gets the personal token used to authenticate against the service. https://docs.microsoft.com/en-us/vsts/accounts/use-personal-access-tokens-to-authenticate?view=vsts
        /// </summary>
        public String PersonalToken { get; private set; }

        /// <summary>
        /// Gets the VSTS user name (optional).
        /// </summary>
        public String UserName { get; private set; }

        #endregion

        #region Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="TeamFoundationServiceClient"/> class.
        /// </summary>
        /// <param name="collectionURL">The collection URL.</param>
        /// <param name="userName">Name of the user.</param>
        /// <param name="personalToken">The personal token.</param>
        public TeamFoundationServiceClient(String collectionURL, String userName, String personalToken)
        {
            CollectionURL = collectionURL;
            UserName = userName;
            PersonalToken = personalToken;
        }

        #endregion

        #region Public Methods

        /// <summary>
        /// Gets a team project by the specified name.
        /// </summary>
        /// <param name="name">The name.</param>
        /// <returns></returns>
        public Task<Project> GetProject(string name)
        {
            return Task.Factory.StartNew<Project>(() =>
            {
                Project p = new Project();

                VssConnection connection = CreateConnection();

                ProjectHttpClient projectClient = connection.GetClient<ProjectHttpClient>();
                TeamProjectReference project = projectClient.GetProjects(null).Result.FirstOrDefault(x => x.Name == name);

                if (project == null)
                {
                    throw new ArgumentException(String.Format("Project '{0}' could not be found.", name));
                }

                p.Name = project.Name;
                p.ID = project.Id;
                p.URL = project.Url;
                p.Description = project.Description;

                TeamHttpClient teamClient = connection.GetClient<TeamHttpClient>();
                var team = teamClient.GetTeamsAsync(project.Id.ToString()).Result.FirstOrDefault();

                IEnumerable<IdentityRef> teamMembers = teamClient.GetTeamMembersAsync(project.Id.ToString(), team.Id.ToString()).Result;

                foreach (var member in teamMembers)
                {
                    TeamMember teamMember = new TeamMember();
                    teamMember.ID = member.Id;
                    teamMember.DisplayName = member.DisplayName;
                    teamMember.ImageURL = member.ImageUrl;
                    teamMember.UniqueName = member.UniqueName;
                    teamMember.URL = member.Url;

                    p.Members.Add(teamMember);
                }

                TaggingHttpClient taggingClient = connection.GetClient<TaggingHttpClient>();
                WebApiTagDefinitionList tags = taggingClient.GetTagsAsync(project.Id).Result;

                foreach (var tag in tags)
                {
                    p.Tags.Add(new Tag()
                    {
                        ID = tag.Id,
                        Name = tag.Name,
                    });
                }

                var projCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(CollectionURL));
                var store = projCollection.GetService<WorkItemStore>();

                WorkItemCollection queryResults = store.Query("Select [State], [Title] " + "From WorkItems " + "Where [Work Item Type] = 'User Story'");

                var userStories = queryResults.OfType<Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem>().Where(x => x.Project.Name == project.Name).ToList();

                foreach (var userStory in userStories)
                {
                    WorkItem story = new WorkItem();

                    story.Type = WorkItemType.UserStory;
                    story.Title = userStory.Title;
                    story.ID = userStory.Id;
                    story.URL = userStory.Uri.ToString();
                    story.Description = userStory.Description;

                    if (userStory.Fields[CoreField.AssignedTo].Value != null)
                    {
                        story.AssignedTo = p.Members.SingleOrDefault(x => x.AssignName == userStory.Fields[CoreField.AssignedTo].Value.ToString());
                    }

                    story.Area = new Area() { Name = userStory.AreaPath };
                    story.Iteration = new Iteration() { Name = userStory.IterationPath };

                    p.UserStories.Add(story);
                }

                p.Areas.Add(new Area() { Name = project.Name, Path = project.Name });

                foreach (var area in store.Projects[project.Name].AreaRootNodes.OfType<Node>())
                {
                    p.Areas.Add(new Area()
                    {
                        Name = area.Name,
                        Path = area.Path,
                    });
                }

                foreach (var iteration in store.Projects[project.Name].IterationRootNodes.OfType<Node>())
                {
                    p.Iterations.Add(new Iteration()
                    {
                        Name = iteration.Name,
                        Path = iteration.Path,
                    });
                }

                return p;
            });
        }

        /// <summary>
        /// Uploads a work item to the specified team project.
        /// </summary>
        /// <param name="project">The project.</param>
        /// <param name="workItem">The work item.</param>
        /// <returns></returns>
        public Task<WorkItem> UploadWorkItem(Project project, WorkItem workItem)
        {
            return Task.Factory.StartNew<WorkItem>(() =>
            {
                var connection = CreateConnection();

                WorkItemTrackingHttpClient witClient = connection.GetClient<WorkItemTrackingHttpClient>();

                var patchDocument = new JsonPatchDocument();

                patchDocument.Add(new JsonPatchOperation
                {
                    Operation = Operation.Add,
                    Path = GetFieldNameForWrite(CoreField.Title),
                    Value = workItem.Title,
                });

                if (!String.IsNullOrWhiteSpace(workItem.Description))
                {
                    patchDocument.Add(new JsonPatchOperation
                    {
                        Operation = Operation.Add,
                        Path = GetFieldNameForWrite(CoreField.Description),
                        Value = workItem.Description,
                    });
                }

                patchDocument.Add(new JsonPatchOperation
                {
                    Operation = Operation.Add,
                    Path = GetFieldNameForWrite(CoreField.IterationPath),
                    Value = workItem.Iteration.Path,
                });

                patchDocument.Add(new JsonPatchOperation
                {
                    Operation = Operation.Add,
                    Path = GetFieldNameForWrite(CoreField.AreaPath),
                    Value = workItem.Area.Path,
                });

                patchDocument.Add(new JsonPatchOperation
                {
                    Operation = Operation.Add,
                    Path = GetFieldNameForWrite(CoreField.AssignedTo),
                    Value = workItem.AssignedTo.AssignName,
                });

                patchDocument.Add(new JsonPatchOperation
                {
                    Operation = Operation.Add,
                    Path = GetFieldNameForWrite(CoreField.CreatedBy),
                    Value = workItem.CreatedBy.AssignName,
                });

                patchDocument.Add(new JsonPatchOperation
                {
                    Operation = Operation.Add,
                    Path = GetFieldNameForWrite(CoreField.ChangedBy),
                    Value = workItem.ChangedBy.AssignName,
                });

                patchDocument.Add(new JsonPatchOperation
                {
                    Operation = Operation.Add,
                    Path = GetFieldNameForWrite(CoreField.AuthorizedAs),
                    Value = workItem.AuthorizedAs.AssignName,
                });

                if (workItem.UserStory != null)
                {
                    patchDocument.Add(
                        new JsonPatchOperation()
                        {
                            Operation = Operation.Add,
                            Path = "/relations/-",
                            Value = new
                            {
                                rel = "System.LinkTypes.Hierarchy-Reverse",
                                url = workItem.UserStory.URL,
                            }
                        }
                    );
                }

                foreach (var attachment in workItem.Attachments)
                {
                    Microsoft.TeamFoundation.WorkItemTracking.WebApi.Models.AttachmentReference attachmentReference = witClient.CreateAttachmentAsync(attachment.FilePath).Result;

                    patchDocument.Add(
                       new JsonPatchOperation()
                       {
                           Operation = Operation.Add,
                           Path = "/relations/-",
                           Value = new
                           {
                               rel = "AttachedFile",
                               url = attachmentReference.Url,
                               attributes = new { comment = attachment.Description, name = attachment.Name }
                           }
                       }
                   );
                }

                if (workItem.Tags.Count > 0)
                {
                    patchDocument.Add(new JsonPatchOperation
                    {
                        Operation = Operation.Add,
                        Path = GetFieldNameForWrite(CoreField.Tags),
                        Value = String.Join("; ", workItem.Tags.Select(x => x.Name)),
                    });
                }

                if (!String.IsNullOrWhiteSpace(workItem.StepsToReproduce))
                {
                    patchDocument.Add(new JsonPatchOperation
                    {
                        Operation = Operation.Add,
                        Path = GetExtensionFieldNameForWrite(ExtensionFields.STEPS_TO_REP),
                        Value = workItem.StepsToReproduce,
                    });
                }

                if (!String.IsNullOrWhiteSpace(workItem.FoundInBuild))
                {
                    patchDocument.Add(new JsonPatchOperation
                    {
                        Operation = Operation.Add,
                        Path = GetExtensionFieldNameForWrite(ExtensionFields.FOUND_IN_BUILD),
                        Value = workItem.FoundInBuild,
                    });
                }

                patchDocument.Add(new JsonPatchOperation
                {
                    Operation = Operation.Add,
                    Path = GetFieldNameForWrite(CoreField.State),
                    Value = workItem.State.ToString(),
                });

                patchDocument.Add(new JsonPatchOperation
                {
                    Operation = Operation.Add,
                    Path = GetExtensionFieldNameForWrite(ExtensionFields.SEVERITY),
                    Value = workItem.Severity.ToDescription(),
                });

                patchDocument.Add(new JsonPatchOperation
                {
                    Operation = Operation.Add,
                    Path = GetExtensionFieldNameForWrite(ExtensionFields.PRIORITY),
                    Value = (int)workItem.Priority,
                });

                patchDocument.Add(new JsonPatchOperation
                {
                    Operation = Operation.Add,
                    Path = GetExtensionFieldNameForWrite(ExtensionFields.SYSTEM_INFO),
                    Value = workItem.SystemInformation,
                });

                var resultWorkItem = witClient.CreateWorkItemAsync(patchDocument, project.Name, workItem.Type.ToString(), bypassRules: true).Result;

                workItem.ID = resultWorkItem.Id.Value;
                workItem.URL = resultWorkItem.Url;

                return workItem;
            });
        }

        /// <summary>
        /// Gets a work item by the specified team project and work item id.
        /// </summary>
        /// <param name="project">The project.</param>
        /// <param name="id">The identifier.</param>
        /// <returns></returns>
        public Task<WorkItem> GetWorkItem(Project project, int id)
        {
            return Task.Factory.StartNew<WorkItem>(() =>
            {
                WorkItem workItem = new WorkItem();

                var connection = CreateConnection();

                WorkItemTrackingHttpClient witClient = connection.GetClient<WorkItemTrackingHttpClient>();

                var item = witClient.GetWorkItemAsync(id, expand: Microsoft.TeamFoundation.WorkItemTracking.WebApi.Models.WorkItemExpand.All).Result;

                workItem.ID = item.Id.Value;
                workItem.Title = item.Fields[GetFieldNameForRead(CoreField.Title)].ToString();
                workItem.Description = TryGetField(item.Fields, GetFieldNameForRead(CoreField.Description));
                workItem.Area = new Area()
                {
                    Path = item.Fields[GetFieldNameForRead(CoreField.AreaPath)].ToString(),
                    Name = Path.GetFileName(item.Fields[GetFieldNameForRead(CoreField.AreaPath)].ToString()),
                };
                workItem.Iteration = new Iteration()
                {
                    Path = item.Fields[GetFieldNameForRead(CoreField.IterationPath)].ToString(),
                    Name = Path.GetFileName(item.Fields[GetFieldNameForRead(CoreField.IterationPath)].ToString()),
                };

                workItem.AssignedTo = project.Members.SingleOrDefault(x => x.AssignName == TryGetField(item.Fields, GetFieldNameForRead(CoreField.AssignedTo)));
                workItem.CreatedBy = project.Members.SingleOrDefault(x => x.AssignName == TryGetField(item.Fields, GetFieldNameForRead(CoreField.CreatedBy)));
                workItem.ChangedBy = project.Members.SingleOrDefault(x => x.AssignName == TryGetField(item.Fields, GetFieldNameForRead(CoreField.ChangedBy)));
                workItem.AuthorizedAs = project.Members.SingleOrDefault(x => x.AssignName == TryGetField(item.Fields, GetFieldNameForRead(CoreField.AuthorizedAs)));

                workItem.Type = (WorkItemType)Enum.Parse(typeof(WorkItemType), item.Fields[GetFieldNameForRead(CoreField.WorkItemType)].ToString());
                workItem.URL = item.Url;

                if (item.Fields.ContainsKey(GetFieldNameForRead(CoreField.Tags)))
                {
                    List<String> tags = item.Fields[GetFieldNameForRead(CoreField.Tags)].ToString().Split(';').Select(x => x.Trim()).ToList();
                    workItem.Tags = tags.Select(x => new Tag() { Name = x }).ToList();
                }

                workItem.FoundInBuild = item.Fields[ExtensionFields.FOUND_IN_BUILD].ToString();

                workItem.State = (State)Enum.Parse(typeof(State), item.Fields[GetFieldNameForRead(CoreField.State)].ToString());

                workItem.Severity = ParseEnumByDescription<Severity>(item.Fields[ExtensionFields.SEVERITY].ToString());

                workItem.Priority = (Priority)int.Parse(item.Fields[ExtensionFields.PRIORITY].ToString());

                workItem.StepsToReproduce = item.Fields[ExtensionFields.STEPS_TO_REP].ToString();

                workItem.SystemInformation = item.Fields[ExtensionFields.SYSTEM_INFO].ToString();

                return workItem;
            });
        }

        /// <summary>
        /// Deletes the specified work item.
        /// </summary>
        /// <param name="project">The project.</param>
        /// <param name="id">The identifier.</param>
        /// <returns></returns>
        public Task DeleteWorkItem(Project project, int id)
        {
            return Task.Factory.StartNew(() =>
            {
                var connection = CreateConnection();

                WorkItemTrackingHttpClient witClient = connection.GetClient<WorkItemTrackingHttpClient>();
                var result = witClient.DeleteWorkItemAsync(id, true).Result;
            });
        }

        #endregion

        #region Private Methods

        /// <summary>
        /// Creates connection to VSTS.
        /// </summary>
        /// <returns></returns>
        private VssConnection CreateConnection()
        {
            VssConnection connection = new VssConnection(new Uri(CollectionURL), new VssBasicCredential(UserName, PersonalToken));
            return connection;
        }

        /// <summary>
        /// Creates a string representation of a VSTS field when reading.
        /// </summary>
        /// <param name="field">The field.</param>
        /// <returns></returns>
        private String GetFieldNameForRead(CoreField field)
        {
            return "System." + field.ToString();
        }

        /// <summary>
        /// Creates a string representation of a VSTS field when writing.
        /// </summary>
        /// <param name="field">The field.</param>
        /// <returns></returns>
        private String GetFieldNameForWrite(CoreField field)
        {
            return "/fields/System." + field.ToString();
        }

        /// <summary>
        /// Creates a string representation of a VSTS extension field when writing.
        /// </summary>
        /// <param name="field">The field.</param>
        /// <returns></returns>
        private String GetExtensionFieldNameForWrite(String extensionFieldName)
        {
            return "/fields/" + extensionFieldName;
        }

        /// <summary>
        /// Returns a value of the specified field key if found. Otherwise return an empty string.
        /// </summary>
        /// <param name="fields">The fields.</param>
        /// <param name="key">The key.</param>
        /// <returns></returns>
        private String TryGetField(IDictionary<String, Object> fields, String key)
        {
            if (fields.ContainsKey(key))
            {
                return fields[key].ToString();
            }

            return String.Empty;
        }

        /// <summary>
        /// Returns the specified enum type value by it's [Description] attribute.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="description">The description.</param>
        /// <returns></returns>
        private T ParseEnumByDescription<T>(String description)
        {
            Dictionary<String, T> values = new Dictionary<string, T>();

            foreach (var item in Enum.GetValues(typeof(T)))
            {
                values.Add(((Enum)item).ToDescription(), (T)item);
            }

            return values[description];
        }

        #endregion
    }
}