Visual Studio Team Foundation Service Agile Bug Logger

• Download source - 19.1 MB

Introduction

We have starting using Visual Studio Team Foundation Services to manage our Agile workload, but I wanted to make sure the tester has a simple and quick way of reporting bugs\features.

Looking around, there are a number of web based applications, which focus on Website logging. We develop desktop application and these solutions did not work good enough for our needs.

Due to this, I created a new simple desktop application, which uses the Visual Studio Team Foundation Services APIs, to create a bug add attachment and notes.

This has given me a good feel on how to use the Visual Studio Team Foundation Services APIs and I want to pass on what I have learned.

Using the Code

The solution uses HTTPClient and JsonConvert.SerializeObject to do JSON calls.
Convert the Data Class object from a Data class to a HTTPContent, which then can be used by JSON.

  public static System.Net.Http.HttpContent ConvertDataClassToJason(object dataClass)
        {
            string wiPostDataString = JsonConvert.SerializeObject(dataClass);

            return  new System.Net.Http.StringContent
               (wiPostDataString, Encoding.UTF8, "application/json-patch+json");
        }

The below method uses HTTPClient to Post or Patch calls and retrieve a result using the APIs.

Post example:

public static async void Post(string url, System.Net.Http.HttpContent wiPostDataContent, 
     string returnType, JSONReturnCallBack callBack)
        {
           string responseString = String.Empty;
           try
           {
                using (System.Net.Http.HttpClient client = new System.Net.Http.HttpClient())
                {
                    client.DefaultRequestHeaders.Accept.Add
                    (new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
 
                  
                    client.DefaultRequestHeaders.Authorization = 
                                 new AuthenticationHeaderValue
                                 ("Basic",Convert.ToBase64String
                                 (System.Text.ASCIIEncoding.ASCII.GetBytes
                                 (string.Format("{0}:{1}", username, password))));


                      using (System.Net.Http.HttpResponseMessage response = 
                      client.PostAsync(url, wiPostDataContent).Result)
                      {
                            response.EnsureSuccessStatusCode();
                            string ResponseContent = await response.Content.ReadAsStringAsync();

                            responseString = ResponseContent;
                      }
                }
            }
            catch(Exception ex)
            {
                            Console.WriteLine(ex.ToString());
                            Console.ReadLine();
            }
           callBack(responseString,returnType);
        }

Patch call

This need a Library added to your Visual studio. You can do this by using nuget.
https://www.nuget.org/packages/Microsoft.VisualStudio.Services.Client

Code snippet to be added

Creating an Work Item

The below example, will take you through the below points

1. Adding new work item
2. Attaching a file
   1. Upload file
   2. Attach to work item

Create a new item

This will show you how to create a simple item within your project on your VSO account

Create the Parameters

When you create an item you need the Title, Description and Tags

   private static void createInitailItemPostObject()
        {                                           
            AddUpdateProp("/fields/System.Title", newTaskItem.Title);
            AddUpdateProp("/fields/System.Tags", newTaskItem.Tags);
            AddUpdateProp("/fields/System.Description", newTaskItem.Description);             
        }

        private static void AddUpdateProp( string field, string value)
        {            
            DataObjectsProject.VSOJasonWorkItemPostData wiPostData = new DataObjectsProject.VSOJasonWorkItemPostData();
            wiPostData.op = "add";
            wiPostData.path = field;
            wiPostData.value = value;
            wiPostDataArr.Add(wiPostData);           
        }

Data Class used to hold the parameters

   public class VSOJasonWorkItemPostData
    {
        public string op;
        public string path;
        public string value;
    }

Sending the Item

Send the Item to VSO to create an work item. This method will return a Id as well as a few other fields.

string NewWorkItem = 
"https://[Account].visualstudio.com/DefaultCollection/[Project]/_apis/wit/workitems/$Task?api-version=1.0";

 Models.Helpers.JASONHelper.Post(newWorkItem, Models.Helpers.JASONHelper.ConvertDataClassToJason
 (wiPostDataArr), "createtask", new Models.Helpers.JASONHelper.JSONReturnCallBack(jsonReturn));         

The JSON call return a string, below will convert the string to a usable object

  public static VSOJasonWorkItemReturnData ConvertDataClassToWorkItemReturnDataObject(string jasonString)
        {
            var wiPostDataString = 
            JsonConvert.DeserializeObject<VSOJasonWorkItemReturnData>(jasonString);
            return wiPostDataString;
           
       }

The data object class used

    public class VSOJasonWorkItemReturnData
    {
        [JsonProperty(PropertyName = "id")]
        public int Id { get; set; }
        [JsonProperty(PropertyName = "rev")]
        public int Rev { get; set; }
        [JsonProperty(PropertyName = "fields")]
        public JsonArrayAttribute  Fields { get; set; }
        [JsonProperty(PropertyName = "links")]
        public JsonArrayAttribute Links { get; set; }
        
    }

Send attachment

You first need to upload an attachment to your Visual Studio Team Foundation Services account.

 string responseString = String.Empty;
            try
            {
                using (System.Net.Http.HttpClient client = new System.Net.Http.HttpClient())
                {
                    client.DefaultRequestHeaders.Authorization =
                                 new AuthenticationHeaderValue("Basic",
                                 Convert.ToBase64String
                                 (System.Text.ASCIIEncoding.ASCII.GetBytes(getConnectionDetails())));

                    FileStream files = new FileStream(filepath, FileMode.Open);
                    StreamContent streamcontent = new StreamContent(files);

                    using (System.Net.Http.HttpResponseMessage response = 
                                    client.PostAsync(SetURL(url),streamcontent).Result)
                    {
                        response.EnsureSuccessStatusCode();
                        responseString = await response.Content.ReadAsStringAsync();
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                Console.ReadLine();
            }

Attach the attachment

Once you have sent the attachment, you then need to attach the attachment to the required work item.

 try
            {
                using (HttpClient client = new System.Net.Http.HttpClient())
                {
  StringBuilder msg = new StringBuilder();
            msg.Append("[{");
            msg.Append("\"op\": \"add\",");
            msg.Append("\"path\": \"/relations/-\",");
            msg.Append("\"value\": {");
            msg.Append("\"rel\": \"AttachedFile\",");
            msg.Append(String.Format("\"url\": \"{0}\",", attachmentUploadReturnObject.URL));
            msg.Append("\"attributes\": {");
            msg.Append(String.Format("\"comment\": \"{0}\"", comment));
            msg.Append("}");
            msg.Append("}");
            msg.Append("}]");
            wiPostDataContent = new System.Net.Http.StringContent(msg.ToString(), 
                             Encoding.UTF8, "application/json-patch+json");

                    client.DefaultRequestHeaders.Accept.Add
                           (new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue
                           ("application/json-patch+json"));

                    client.DefaultRequestHeaders.Authorization =
                                 new AuthenticationHeaderValue("Basic", Convert.ToBase64String
                                 (System.Text.ASCIIEncoding.ASCII.GetBytes(getConnectionDetails())));
                  
                    using (System.Net.Http.HttpResponseMessage response = 
                           client.PatchAsync(SetURL(url), wiPostDataContent).Result)
                    {
                        response.EnsureSuccessStatusCode();
                        string ResponseContent = await response.Content.ReadAsStringAsync();

                        responseString = ResponseContent;
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                Console.ReadLine();
            }

Points of Interest

You can have a look at the application in more detail:

1. Published version from the online site
2. See the code within the downloadable
3. Look at the code within the GitHub repo

Published Application: http://bugs.coopsmill.com
GitHUB: https://github.com/chriscooper01/VSODesktop.git
The API Documentation: https://www.visualstudio.com/en-us/docs/integrate/api/overview

History

• 28^th June, 2016: Initial version