Larry Wall haz dem

Larry Wall, the creator of the infamous Perl programming language, has once said that the greatest virtues of a good programmer are Laziness, Impatience and Hubris. To not mislead the lazy “computer science” students, allow me to define each virtues:

1. Laziness — The quality that makes you go to great effort to reduce overall energy expenditure. It makes you write labor-saving programs that other people will find useful, and document what you wrote so you don’t have to answer so many questions about it. Hence, the first great virtue of a programmer. See also impatience and hubris.
2. Impatience – The anger you feel when the computer is being lazy. This makes you write programs that don’t just react to your needs, but actually anticipate them. Or at least pretend to. Hence, the second great virtue of a programmer. See also laziness and hubris.
3. Hubris – Excessive pride. Also the quality that makes you write (and maintain) programs that other people won’t want to say bad things about. Hence, the third great virtue of a programmer. See also laziness and impatience.

A few days ago, a tester at our company filled a track that contained multiple attachments (Screenshots, Error Logs, etc) to assist the developers on their investigation. As we are using Microsoft’s Team Foundation System for source control and bug tracking, the most obvious way to get these attachments is through TFS Web Access; Frankly speaking, this is the only “official” way to access the track (bug report) on our company.

The TFS Web Access homepage UI

I don’t know if its a lack of feature or what, but there is no way in TFS Web Access to download multiple attachments at once. Additionally, when downloading attachments that contains a space on their filename, TFS Web Access will automatically concatenate the filename and that will remove the file’s extension (EG: Screenshot of the bug.jpg will be renamed to Screenshot)… You still need to manually rename the file with the proper extension to open it. And because I’m lazy, I don’t want to log-in to TFS Web Access, type in the track ID, click on the attachments tab, click on the file(s) I want to download, browse for the location where to save the file, create a new folder for the track, click save, minimize my browser, open the download location and (unzip the attachment, it its zipped, which normally is) to just view a single screenshot.

Since I am a big believer of Wall’s three virtues, I created a tool that will automate those boring and repetitive tasks for me (and allow me to download *all* attachments from a work item + workaround the “spacing” bug). The tool is called WIF or Work Item Fetcher and it is currently in Closed-Limited Beta.

At first, I thought about parsing the web pages to download the attachments using HTML Sanitizers and Regular Expressions but then I remembered that only Chuck Norris can parse HTML using regular expressions! So I searched the web and found out about the TFS SDK! Go .NET! Go Laziness! Okay, enough chit-chat, the rest of the post will be dedicated to discussing how to use the TFS API to download attachments from TFS.

Step 1: Acquiring the needed libraries

To be honest, I don’t really know where to download the DLLs. I’ve searched and found nothing. What I did was I referenced the DLLs located at C:\Program Files\Microsoft Visual Studio 8\Common7\IDE\PrivateAssemblies\. The DLLs should be available after you download and install Team Explorer for Visual Studio 2005. For our purposes, you should reference the following DLLs:

• Microsoft.TeamFoundation.DLL
• Microsoft.TeamFoundation.Client.DLL
• Microsoft.TeamFoundation.WorkItemTracking.Client.DLL

You must then add the needed declarations like so:

using Microsoft.TeamFoundation;
using Microsoft.TeamFoundation.Client;
using Microsoft.TeamFoundation.WorkItemTracking.Client;

Compile your project to check. Remember to always compile your project after each step.

Step 2: Connecting to your TFS server

If you want to do anything with your TFS SDK, the first thing that you should do is to connect to your TFS server. Connecting is straight-forward, but a little tricky if you need to provide your network credentials. First, lets assume that the program will run on a machine that is connected to the domain with the proper credentials (AKA straight-forward way):

const string TFSServer = "http://mytfsserver:8090";
 
using (TeamFoundationServer tfsConn = new TeamFoundationServer(TFSServer))
{
	try
	{
		tfsConn.EnsureAuthenticated();
	}
	catch (Exception ex)
	{
		MessageBox.Show(ex.Message, "Cannot connect to TFS Server!", MessageBoxButtons.OK, MessageBoxIcon.Error);
	}
}

A call to EnsureAuthenticated(); is needed to check if your connection is properly authenticated. If not, the method will throw an exception.

How about if you need to manually provide login credentials or your machine is not joined to a domain? Just use the NetCredential object from System.Net to pass your credentials:

const string TFSServer = "http://mytfsserver:8090";
 
NetworkCredential netCred = new NetworkCredential("Username", "Password", "Domain");
 
using (TeamFoundationServer tfsConn = new TeamFoundationServer(TFSServer, netCred))
{
	try
	{
		tfsConn.EnsureAuthenticated();
	}
	catch (Exception ex)
	{
		MessageBox.Show(ex.Message, "Cannot connect to TFS Server!", MessageBoxButtons.OK, MessageBoxIcon.Error);
	}
}

Step 3: Acquire the Work Item

Now that we’re good and connected to TFS, our next task is to acquire the Work Item from TFS. First, we’ll need to acquire the WorkItemStore service from TFS by calling the GetService method:

WorkItemStore wis = (WorkItemStore)tfsServer.GetService(typeof(WorkItemStore));

Then, we’ll get the Work Item by invoking the GetWorkItem method:

WorkItem wi = wis.GetWorkItem(1000); //Where 1000 is the Work Item ID

Now, your code should look something like this:

const string TFSServer = "http://mytfsserver:8090";
 
NetworkCredential netCred = new NetworkCredential("Username", "Password", "Domain");
 
using (TeamFoundationServer tfsConn = new TeamFoundationServer(TFSServer, netCred))
{
	try
	{
		tfsConn.EnsureAuthenticated();
                WorkItemStore wis = (WorkItemStore)tfsServer.GetService(typeof(WorkItemStore));
                WorkItem wi = wis.GetWorkItem(1000); //Where 1000 is the Work Item ID
	}
	catch (Exception ex)
	{
		MessageBox.Show(ex.Message, "Something has gone wrong!", MessageBoxButtons.OK, MessageBoxIcon.Error);
	}
}

Step 4: Get the attachments’ URI

After acquiring the Work Item, we can now directly iterate through the attachment collection to access its attachment’s URI:

foreach(Attachment attachment in wi.Attachments)
{
	string FileName = attachment.Name;
	string attachmentURI = attachment.Uri;
}

Cool huh? Just like that! Your entire code should look like this:

const string TFSServer = "http://mytfsserver:8090";
 
NetworkCredential netCred = new NetworkCredential("Username", "Password", "Domain");
 
using (TeamFoundationServer tfsConn = new TeamFoundationServer(TFSServer, netCred))
{
	try
	{
		tfsConn.EnsureAuthenticated();
                WorkItemStore wis = (WorkItemStore)tfsServer.GetService(typeof(WorkItemStore));
                WorkItem wi = wis.GetWorkItem(1000); //Where 1000 is the Work Item ID
 
		foreach(Attachment attachment in wi.Attachments)
		{
			string FileName = attachment.Name;
			string attachmentURI = attachment.Uri;
		}
 
	}
	catch (Exception ex)
	{
		MessageBox.Show(ex.Message, "Something has gone wrong!", MessageBoxButtons.OK, MessageBoxIcon.Error);
	}
}

Step 5: Downloading the attachments

And now that we have the attachment’s URI, all there is left to do is to download it. Thankfully, .NET provided us with the WebClient class that simplifies the downloading:

using (WebClient wClient = new WebClient())
{
	wClient.Credentials = netCred; //Provide your network credentials.
	wClient.DownloadFile(attachment.Uri, Path.Combine(@"C:", attachment.Name));
}

That’s it! You’re done. The completed code should look like this:

using (TeamFoundationServer tfsConn = new TeamFoundationServer(TFSServer, netCred))
{
	try
	{
		tfsConn.EnsureAuthenticated();
                WorkItemStore wis = (WorkItemStore)tfsServer.GetService(typeof(WorkItemStore));
                WorkItem wi = wis.GetWorkItem(1000); //Where 1000 is the Work Item ID
 
		foreach(Attachment attachment in wi.Attachments)
		{
			string FileName = attachment.Name;
			string attachmentURI = attachment.Uri;
 
			using (WebClient wClient = new WebClient())
			{
				wClient.Credentials = netCred;
				wClient.DownloadFile(attachmentURI, Path.Combine(@"C:", FileName));
			}
		}
 
	}
	catch (Exception ex)
	{
		MessageBox.Show(ex.Message, "Something has gone wrong!", MessageBoxButtons.OK, MessageBoxIcon.Error);
	}
}

Step 6: Optional Improvements

The code above is the minimum required to have a fully functional attachment downloader for TFS. There are a couple of things that you can do to improve your program:

• Automatically create a directory for each Work Item. This way, you will have an organized local storage of the attachments.
• Instead of using the DownloadFile method to download your file, you can use the DownloadFileAsync method to download the file asynchronously. DownloadFileAsync is non-thread blocking. This call will also allow you to listen to EventHandlers for the download progress.
• After the download, you can check if the file is a zip file (by using Path.GetExtension), and if it is, you can use SharpZipLib to automatically unzip the package.
• Sometimes, instead of providing the Incident number, your users will provide the Incident Fix number. Its good to anticipate that and provide a way to resolve the Incident Number from the Incident Fix. To do that, first check if your user provided an Incident Fix by calling wi.Fields.GetById(25).Value.ToString() == “Incident Fix” then if yes, you can get the Incident Number by calling int ParentID = (int)wi.Fields.GetById(10120).Value. Thank you Impatience!

I can’t really share my program with you guys (you know all of that “corporate” legal mumbo-jumbo). But here’s the screenshot:

Work Item Fetcher @ TFS

Thank you Laziness for making me go to great effort to reduce the total effort and time needed to download attachments from TFS. Thank you for making me write labor-saving programs that other people will hopefully find useful.

Thank you Impatience for pissing me off when I am manually downloading and renaming attachments one by one. Thank you too for making me angry when my initial prototype failed when I gave it an Incident Fix number rather than an Incident number.

And, as always, thank you Hubris! (People around me knows exactly why!)

The training is about Windows Communication Framework or WCF — Microsoft’s answer to building Service-Oriented Architectures (SOA). Gone were the days of Web Services, more so, socket programming! It’s all abstracted now. Yay for lame programmers!

But anyway, the training was GREAT! I was able to learn the ins and outs of WCF. But what’s interesting is that I learned a new “way” to do rollbacks automatically! It’s called…

TRANSACTIONS!

But what’s more interesting is that Transactions is not really part of the WCF nor the.NET 3.5. It’s an existing feature from .NET 1.1! )So what’s Transactions? Well, its really hard to explain so I’ll just present a scenario on how and where you can use Transactions.

Let’s say that you have a Point of Sales (POS) system that have 2 tables namely Inventory table and Sales table. And you have a method called CustomerBuysStuff(int ItemID). The said method will be called if a customer buys new stuff (obviously)… so the implementation would be something like:

1. Deduct 1 unit from the Inventory table using the ItemID
2. Add 1 unit from the Sales table using the ItemID

This means that this particular method must execute two (2) SQL statements and both of them must SUCCEED or you will have a decrepancy on your data. If you can remember from your Database Management Course, you have studied a concept called ACID. This scenerio represents the A in ACID — Atomic Operations. In our case, this means that “All statements in a group must execute, or no statement in a group must execute. “

Frequently in a database application you come across a situation where you need to execute two or more SQL commands in such a way that if any one of the statements fails, then no other statement will be able to change the database.

I’ll try to demonstrate Transactions using REAL code (Click the image to enlarge):

Let’s call the code snippet as “No Rollback”. This assumes that you are 101% sure that both operation will succeed that you did not even bother to write a rollback method if ever one of the two fails. This is a very bad practice in the real world because it will create a discrepancy in your data that cannot be traced — and worst, debugged.

The above code snippet is called “With Rollback”, because in this code snippet, when the second command fails, you cared enough to rollback the changes made by the first command. This is how I did it in the college days when I’m too lazy to use Stored Procedures (and TRANS/COMMIT) and I’m too stupid to not have researched about Transactions! Oh the dark ages. Mind you, this method is not 100% fool-proof. What will happen if your rollback command also failed? Discrepancy!

Now, let’s call this code snippet “Almighty Transaction”. In the above code, there is no extra method or SQL command to invoke to do the rollback when the pre-requisite part of your code fails. And oh, there’s also no extra code to detect an exception or an error. It just magically knows that something awful had happened and it will just magically rollback ALL the changes that happened before the error. Like, MAGICALLY! Isn’t it freakin great?!

Also, this will work on ANYTHING (Not only on Database Related Stuffs). During my thesis days, I have to write a method to perform rollbacks when my encryption/decyption algorithm fails. It took me a whole week and lots of messy code to make it work perfectly. If only I have the knowledge of Transactions then, it could have just taken me 5 minutes. DAMN!
So yeah… I love these TRAININGS (Have 6 more to go for this year)! You can learn lots of useful stuffs in a very short span of time (Like 3 days). They will even give you a certificate that is signed by Billy-G himself! Haha! Another additional line in my Resume.

What’s great about the training company that my company chose is that they are official Microsoft Partners… This means that I can take the official WCF Online Test and if I pass, I will then be a “Certified” MCP (Microsoft Certified Professional)!

Remember…

TransactionScope AtomicScope = new TransactionScope()
using(AtomicScope)
{
//ATOMIC OPERATIONS
AtomicScope.Complete();
}