Team System

Learning more about Visual Studio 2008

Martin Hinshelwood — Tue, 06 Jan 2009 08:16:03 GMT

Well, that's me well and truly back from my holidays, a nice relaxing couple of weeks spent at home with my family.

As a kind of New Years present, Microsoft has released a free learning initiative for those of you that are or will be using Visual Studio 2008. I am taking it myself as a way to make sure that I have not missed anything :)

Technorati Tags: Free,Free Training,Visual Studio 2008,Team System

Managing the “VSTS Developers” LinkedIn group.

Martin Hinshelwood — Mon, 15 Dec 2008 11:51:12 GMT

After making sending a “Call to Action” to my fellow Team System MVP’s I have added two managers to the VSTS Developers group I started on LinkedIn.

Ed Blankenship - [LinkedIn] [Blog] [Company blog]
Michael Ruminer - [LinkedIn] [Blog]

Thanks guys for giving up a little bit of your valuable time….

Hopefully, this will give members more information and a faster response time to requests…

Technorati Tags: VSTS,Visual Studio Team System,TFS,Team Foundation Server,Team System

TFS Event Handler v1.3 released

Martin Hinshelwood — Tue, 02 Dec 2008 11:08:37 GMT

Updated and improved for Team System 2008.

http://www.codeplex.com/TFSEventHandler

The TFS Event Handler makes it easier to notify users of changes to Work Items in Team Foundation Server. You will no longer need to add individual alerts to users.

It is developed in .NET 3.5 SP1 for Team Foundation Server 2008 and is deployed as a system service.

I have added support for groups. If you add a TFS group into the Assigned To drop down all members of that group will receive notifications!

You will need to allow groups in your Assigned to list. Below is a snippet from me Bug work item type as it stands at the moment.

   1: <FIELD reportable="dimension" type="String" name="Assigned To" refname="System.AssignedTo">

   2:     <HELPTEXT>The person assigned to act on the bug, either to fix it or to verify the fix</HELPTEXT>

   3:     <ALLOWEXISTINGVALUE />

   4:     <ALLOWEDVALUES filteritems="excludegroups">

   5:         <LISTITEM value="[project]\Contributors" />

   6:     </ALLOWEDVALUES>

   7: </FIELD>

You can see on line 4 that there is a filter for excluding the groups from the list. If you are using TFS Event Handler v1.0 or v1.1 then you will need this line. If you install the new TFS Event Handler v1.3 then you will be able to remove that and start assigning work items to Groups.

Note: Although they will now get an email, the work item will not appear in their “My Work items” query. You may want to consider creating a Query for each Group.

The Alerts that you no longer need users to individually setup are:

A work item is assigned to you, or a group you are a member of.
A work item that is assigned to you, or a group you are a member of is, reassigned to someone else.
A work item that you created is assigned to someone else, or a group.

There is also a framework for creating and deploying your own event handlers that can do pretty much whatever you want. One of the shipped examples updates “Heat ITSM” whenever a work item that contains a Heat Id is changed.

Technorati Tags: TFS,VSTS,Team System,Team Foundation Server,Visual Studio Team System,TFS Event Handler

Retrieving an identity from Team Foundation Server using only the display name

Martin Hinshelwood — Mon, 01 Dec 2008 17:30:26 GMT

This is a lot harder than it sounds. At first you think there will be a built in option with the Read Identities method on the IGroupSecurityService Interface, but you would be wrong!

When capturing an event from Team Foundation Server you have access to a lot of information about the change, including the Display Name of the fields for Assigned To and Changed By.

But what if you allow Work Items to be assigned to groups! First, lets achieve that. Create a group called “Program Management” on a project and add it into the “Contributors” list. We have a group for each of the advocacy groups in the CMMI process.

Edit your “Task” work item definition (you can use the power tools process editor or just edit the XML) and alter the Assigned To field to be the following:

   1: <FIELD reportable="dimension" type="String" name="Assigned To" rename="System.AssignedTo">

   2:   <ALLOWEXISTINGVALUE />

   3:   <ALLOWEDVALUES>

   4:     <LISTITEM value="[project]\Contributors" />

   5:   </ALLOWEDVALUES>

   6: </FIELD>

Once you have updated your project you should be able to see all of the users as well as this new group displayed. If you were to assign a task to this group, how would you email everyone in that group so that they know they have been assigned something at all?

Well this needs a wee tweak of the TFS Event Handler to handle this, I will be releasing the full in place code with the TFS Event Handler v1.3 drop, but you can download my little test app I used to get it all working.

[Download Project]

You can enter a display name of either a user or a group. And here is how it is done:

There is a little but of Active Directory lookup using a little method called GetUsername

   1: '' <summary>

   2: '' Retrieves a user's email address from Active Directory based on their display name

   3: '' </summary>

   4: Public Shared Function GetUsername(ByVal userDisplayName As String) As String

   5:     Dim ds As DirectoryServices.DirectorySearcher = New DirectoryServices.DirectorySearcher()

   6:     ds.PropertiesToLoad.Add("sAMAccountName")

   7:     ds.Filter = String.Format("(&(displayName={0})(objectCategory=person)((objectClass=user)))", userDisplayName)

8:

   9:     Dim results As DirectoryServices.SearchResultCollection = ds.FindAll()

  10:     If results.Count = 0 Then

  11:         Return String.Empty

  12:     End If

  13:     Dim values As DirectoryServices.ResultPropertyValueCollection = results(0).Properties("sAMAccountName")

  14:     If values.Count = 0 Then

  15:         Return String.Empty

  16:     End If

  17:     Return values(0).ToString()

  18: End Function

This retrieves the users sAMAccountName (or username) from Active Directory. Easy enough, and I already had it kicking about…

But in order to retrieve an identity that you are not sure is a group or a user, you will need to try to get the Group Identity first. This is because it is faster to wade through a maximum of 20 groups than potentially hundreds of users mentioned on the MSDN Forum answer below.

   1: Try

   2:            '----------------------------------------

   3:            Dim svr As New TeamFoundationServer(Me.uxTeamServer.Text)

   4:            Dim GroupSecurityService As IGroupSecurityService = CType(svr.GetService(GetType(IGroupSecurityService)), IGroupSecurityService)

   5:            '----------------------------------------

   6:            Dim CommonStructureService As ICommonStructureService = CType(svr.GetService(GetType(ICommonStructureService)), ICommonStructureService)

   7:            '----------------------------------------

   8:            ' Return App Group if you can

   9:            Dim pi As ProjectInfo = m_CommonStructureService.GetProjectFromName(Me.uxProject.Text)

  10:            Dim appGroup As Identity = (From i In m_GroupSecurityService.ListApplicationGroups(pi.Uri) Where i.DisplayName = Me.uxDisplayName.Text).SingleOrDefault

  11:            If Not appGroup Is Nothing Then

  12:                appGroup = m_GroupSecurityService.ReadIdentity(SearchFactor.Sid, appGroup.Sid, QueryMembership.Expanded)

  13:                WriteToLog(String.Format("Recieved identity for {0}", Me.uxDisplayName.Text))

  14:                WriteIdentity(appGroup)

  15:                Exit Try

  16:            End If

  17:            ' Not app group. Then return user is you can

  18:            Dim username As String = GetUsername(Me.uxDisplayName.Text)

  19:            Dim usrIdent As Identity = m_GroupSecurityService.ReadIdentity(SearchFactor.AccountName, username, QueryMembership.Expanded)

  20:            If Not usrIdent Is Nothing Then

  21:                WriteToLog(String.Format("Recieved identity for {0}", username))

  22:                WriteIdentity(usrIdent)

  23:                Exit Try

  24:            End If

  25:            '----------------------------------------

  26:            WriteToLog(String.Format("identity for {0} not found", Me.uxDisplayName.Text))

27:

  28:            '----------------------------------------

  29:        Catch ex As Exception

  30:            Me.uxResults.Items.Add(ex.ToString)

  31:        End Try

There is a lot going on here, but the first thing you need to do is retrieve the TFS objects that we will need to work with which include a TeamFoundationServer instance as well as an IGroupSecurityService and ICommonStructureService. You could use the WorkItemStore instead of the ICommonStructureService, but the WorkItemStore has a heavy performance hit for retrieving an instance.

   1: Dim svr As New TeamFoundationServer(Me.uxTeamServer.Text)

   2: Dim GroupSecurityService As IGroupSecurityService = CType(svr.GetService(GetType(IGroupSecurityService)), IGroupSecurityService)

   3: Dim CommonStructureService As ICommonStructureService = CType(svr.GetService(GetType(ICommonStructureService)), ICommonStructureService)

Next we need to try and retrieve the Identity of the group, if it is one. The ICommonStructureService has a method for listing all of the Groups available within a project, but for that you need the project name which in the demo is just entered.

   1: ' Return App Group if you can

   2: Dim pi As ProjectInfo = m_CommonStructureService.GetProjectFromName(Me.uxProject.Text)

   3: Dim appGroup As Identity = (From i In m_GroupSecurityService.ListApplicationGroups(pi.Uri) Where i.DisplayName = Me.uxDisplayName.Text).SingleOrDefault

   4: If Not appGroup Is Nothing Then

   5:   appGroup = m_GroupSecurityService.ReadIdentity(SearchFactor.Sid, appGroup.Sid, QueryMembership.Expanded)

   6:   WriteToLog(String.Format("Recieved identity for {0}", Me.uxDisplayName.Text))

   7:   WriteIdentity(appGroup)

   8:   Exit Try

   9: End If

What this does is use the project name entered (in the event it is under the element ProtfolioProject (yea, I don’t know why it is called that either) to search a list of Group’s within your project for the one of interest.

Then, as it does not by default load the “Members” and “MemberOf” arrays you need to call ReadIdentity with the Expand option is you want to list the Members, and I do.

If this does not return an identity, then we need to look at the display name being a user account.

   1: ' Not app group. Then return user is you can

   2: Dim username As String = GetUsername(Me.uxDisplayName.Text)

   3: Dim usrIdent As Identity = m_GroupSecurityService.ReadIdentity(SearchFactor.AccountName, username, QueryMembership.Expanded)

   4: If Not usrIdent Is Nothing Then

   5:   WriteToLog(String.Format("Recieved identity for {0}", username))

   6:   WriteIdentity(usrIdent)

   7:   Exit Try

   8: End If

Actually quite easy, but it could be easier.

Example WorkItemChangedEvent:

   1: <?xml version="1.0" encoding="utf-8"?>

   2: <WorkItemChangedEvent xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">

   3:   <PortfolioProject>TFS Sticky Buddy</PortfolioProject>

   4:   <ProjectNodeId>614c944e-7799-46a2-a519-30e68eea040b</ProjectNodeId>

   5:   <AreaPath>\TFS Sticky Buddy</AreaPath>

   6:   <Title>TFS Sticky Buddy Work Item Changed: Requirement 1267 - Visual Enhancement</Title>

   7:   <WorkItemTitle>Mobility Continental Exceptions Report</WorkItemTitle>

   8:   <Subscriber>HINSHDOM\svc_tfsservices</Subscriber>

   9:   <ChangerSid>S-1-5-21-1390067357-651377827-682003330-21716</ChangerSid>

  10:   <DisplayUrl>http://tfs01.hinshelwood.com:8080/workitemtracking/workitem.aspx?artifactmoniker=1267</DisplayUrl>

  11:   <TimeZone>GMT Standard Time</TimeZone>

  12:   <TimeZoneOffset>00:00:00</TimeZoneOffset>

  13:   <ChangeType>Change</ChangeType>

  14:   <CoreFields>

  15:     <IntegerFields>

  16:       <Field>

  17:         <Name>ID</Name>

  18:         <ReferenceName>System.Id</ReferenceName>

  19:         <OldValue>1267</OldValue>

  20:         <NewValue>1267</NewValue>

  21:       </Field>

  22:       <Field>

  23:         <Name>Rev</Name>

  24:         <ReferenceName>System.Rev</ReferenceName>

  25:         <OldValue>4</OldValue>

  26:         <NewValue>5</NewValue>

  27:       </Field>

  28:       <Field>

  29:         <Name>AreaID</Name>

  30:         <ReferenceName>System.AreaId</ReferenceName>

  31:         <OldValue>551</OldValue>

  32:         <NewValue>551</NewValue>

  33:       </Field>

  34:     </IntegerFields>

  35:     <StringFields>

  36:       <Field>

  37:         <Name>Work Item Type</Name>

  38:         <ReferenceName>System.WorkItemType</ReferenceName>

  39:         <OldValue>Requirement</OldValue>

  40:         <NewValue>Requirement</NewValue>

  41:       </Field>

  42:       <Field>

  43:         <Name>Title</Name>

  44:         <ReferenceName>System.Title</ReferenceName>

  45:         <OldValue>Visual Enhancement</OldValue>

  46:         <NewValue>Visual Enhancement</NewValue>

  47:       </Field>

  48:       <Field>

  49:         <Name>Area Path</Name>

  50:         <ReferenceName>System.AreaPath</ReferenceName>

  51:         <OldValue>\TFS Sticky Buddy</OldValue>

  52:         <NewValue>\TFS Sticky Buddy</NewValue>

  53:       </Field>

  54:       <Field>

  55:         <Name>State</Name>

  56:         <ReferenceName>System.State</ReferenceName>

  57:         <OldValue>Active</OldValue>

  58:         <NewValue>Active</NewValue>

  59:       </Field>

  60:       <Field>

  61:         <Name>Reason</Name>

  62:         <ReferenceName>System.Reason</ReferenceName>

  63:         <OldValue>Accepted</OldValue>

  64:         <NewValue>Accepted</NewValue>

  65:       </Field>

  66:       <Field>

  67:         <Name>Assigned To</Name>

  68:         <ReferenceName>System.AssignedTo</ReferenceName>

  69:         <OldValue>Mike Hunt</OldValue>

  70:         <NewValue>Mike Hunt</NewValue>

  71:       </Field>

  72:       <Field>

  73:         <Name>Changed By</Name>

  74:         <ReferenceName>System.ChangedBy</ReferenceName>

  75:         <OldValue>Martin Hinshelwood</OldValue>

  76:         <NewValue>Mike Hunt</NewValue>

  77:       </Field>

  78:       <Field>

  79:         <Name>Created By</Name>

  80:         <ReferenceName>System.CreatedBy</ReferenceName>

  81:         <OldValue>Mike Hunt</OldValue>

  82:         <NewValue>Mike Hunt</NewValue>

  83:       </Field>

  84:       <Field>

  85:         <Name>Changed Date</Name>

  86:         <ReferenceName>System.ChangedDate</ReferenceName>

  87:         <OldValue>01/12/2008 16:05:21</OldValue>

  88:         <NewValue>02/12/2008 12:17:08</NewValue>

  89:       </Field>

  90:       <Field>

  91:         <Name>Created Date</Name>

  92:         <ReferenceName>System.CreatedDate</ReferenceName>

  93:         <OldValue>01/12/2008 13:51:22</OldValue>

  94:         <NewValue>01/12/2008 13:51:22</NewValue>

  95:       </Field>

  96:       <Field>

  97:         <Name>Authorized As</Name>

  98:         <ReferenceName>System.AuthorizedAs</ReferenceName>

  99:         <OldValue>Martin Hinshelwood</OldValue>

 100:         <NewValue>Mike Hunt</NewValue>

 101:       </Field>

 102:       <Field>

 103:         <Name>Iteration Path</Name>

 104:         <ReferenceName>System.IterationPath</ReferenceName>

 105:         <OldValue>\TFS Sticky Buddy\R4</OldValue>

 106:         <NewValue>\TFS Sticky Buddy\R4</NewValue>

 107:       </Field>

 108:     </StringFields>

 109:   </CoreFields>

 110:   <ChangedFields>

 111:     <IntegerFields />

 112:     <StringFields>

 113:       <Field>

 114:         <Name>Changed By</Name>

 115:         <ReferenceName>System.ChangedBy</ReferenceName>

 116:         <OldValue>Martin Hinshelwood</OldValue>

 117:         <NewValue>Mike Hunt</NewValue>

 118:       </Field>

 119:     </StringFields>

 120:   </ChangedFields>

 121: </WorkItemChangedEvent>

And what did I have to use to figure this out?

As you can see there was a lot of research, which does not include all the stuff I already know from doing the TFS Sticky Buddy and the TFS Event Handler.

I think that this was an unnecessary complexity and there should be an additional option for the Search Factor enumeration should be added to make this easier.

TFS Event Handler v1.1 released

Martin Hinshelwood — Fri, 28 Nov 2008 11:38:25 GMT

Updated and improved for Team System 2008.

http://www.codeplex.com/TFSEventHandler

The TFS Event Handler makes it easier to notify users of changes to Work Items in Team Foundation Server. You will no longer need to add individual alerts to users.

It is developed in .NET 3.5 SP1 for Team Foundation Server 2008 and is deployed as a system service.

The Alerts that you no longer need users to individually setup are:

A work item is assigned to you.
A work item that is assigned to you is reassigned to someone else.
A work item that you created is assigned to someone else.

Technorati Tags: TFS,VSTS,Team System,Team Foundation Server,Visual Studio Team System,TFS Event Handler

Visual Studio Team System 2008 Database Edition GDR Installation

Martin Hinshelwood — Wed, 26 Nov 2008 10:42:23 GMT

First, download the new Data Dude.

Download page
http://www.microsoft.com/downloads/details.aspx?FamilyID=bb3ad767-5f69-4db9-b1c9-8f55759846ed&displaylang=en
Setup
http://download.microsoft.com/download/0/a/e/0ae1153a-8798-474a-93e6-d19299f37c8b/setup.exe

Read Me
http://download.microsoft.com/download/0/a/e/0ae1153a-8798-474a-93e6-d19299f37c8b/Readme.mht

Documentation:
http://download.microsoft.com/download/0/a/e/0ae1153a-8798-474a-93e6-d19299f37c8b/Documentation.zip

Once you get it going the install is pretty easy. Things to watch out for are:

Remove all previous versions before the install. This included any CTP or RC versions.
You will NOT be able to upgrade your projects built with the CTP releases! You should however be able to upgrade any projects built with the RC.

Installation

Uninstall old GDR versions

If you have a previous version of the GDR installed, you will have to uninstall these first. You can do this via Add/Remove Programs or from the command line using:

· msiexec /X {DDF197C6-4507-3A19-A4B5-0E17CC931370}

Prerequisites

Before you start downloading and installing please check if the following pre-requisites are present on your machine!

Visual Studio 2008 SP1 RTM (make sure this is the RTM not the beta of SP1, the GDR will not install with the beta release of SP1)

Microsoft SQL Server Compact Edition 3.5 SP1 (this is normally included in the setup of VS 2008 SP1)

Installation

You can download the Visual Studio Team System 2008 Database Edition GDR from the following location:

Setup
http://download.microsoft.com/download/0/a/e/0ae1153a-8798-474a-93e6-d19299f37c8b/setup.exe

Read Me
http://download.microsoft.com/download/0/a/e/0ae1153a-8798-474a-93e6-d19299f37c8b/Readme.mht

Documentation:
http://download.microsoft.com/download/0/a/e/0ae1153a-8798-474a-93e6-d19299f37c8b/Documentation.zip
Contains:

Visual Studio Team System 2008 Database Edition GDR User Manual

Visual Studio Team System 2008 Database Edition GDR API Reference

Luckily I have just received a new install of Vista 64, so I have no previous versions to remove ;)

Once the install if finished you will see that the GDR has replaced the standard Database Edition in visual studio.

The “New Project” window will also have additional options and you can see the two new sort of project, “Database” and “Server”.

If you pick the “Wizard” you will be presented with a set of options for your project creation. Loads of people have documented what these options mean, so I will just give you a flavor with a wee video…

Please be patient with my videos as I am just getting to grips with this.

Technorati Tags: VSTS,TFS,Team System,Visual Studio Team System,Database Edition,Visual Studio 2008,Visual Studio 2005,SQL Server,SQL Server 2008,SQL Server 2000,SQL Server 2005

Visual Studio Team System 2008 Database Edition GDR has been released!

Martin Hinshelwood — Wed, 26 Nov 2008 09:55:11 GMT

What a mouthful! Has there ever been any products with names as long as the Team System toolset ;), Maybe thats why it is just called Data Dude.

Anyway, congratulations to the Data Dude team for this wonderful piece of work. I have been following the GDR for a while and I have been very impressed with the capabilities on offer.

Although this is billed as a new release of Data Dude, it is really a completely new product with a brand new architecture. They have made many improvements to scalability, and they have added many extensibility points (Microsoft speak for places where you can inject your own functionality).

Model based architecture

Everything underneath the covers is based on a true model representation of the SQL Server schema. This facilitates a true offline declarative database development system where the source code defines the shapes of the schema objects.

Database Schema Providers

Models are implemented by Database Schema Providers, DSP's for short. - The introduction of a provider model enables multiple things at once. First of all the decoupling of release vehicles. For example when SQL Server will release a new version or adds new functionality in a service pack, like they did in SQL Server 2005 SP2 when adding "vardecimal" support, we can simply update an existing provider or provide a new one in case of a new SQL Server release. Overtime we will go to a model where the SQL Server providers will be an integral part of the SQL Server release. The provider model is also a key extensibility point, allowing 3rd parties to extend database project ecosystem and add support for other database platforms in Visual Studio Team System 2010.

Tool extensibility

In this release external tool writers have full access to the T-SQL parsers (for SQL Server 2000, 2005 and 2008), the SQL Script DOM and the schema model (when inside Visual Studio). This adds on top of the ability to write extend the tools inside the platform. You can extend T-SQL refactoring by writing your own refactoring types (operations) and refactoring targets; add T-SQL Static Code Analysis rules, data generators, data distributions and test conditions. Database Projects (.dbproj) now provide a truly extensible declarative database development platform.

Separation of BUILD and DEPLOY

The separation of build & deploy makes it possible to deploy the output of your database project to many different targets and different points in time. Build now produces a single artifact file hat describes the schema inside your database, called a .DBSCHEMA file. This file is used by the deployment engine to deploy your schema.

Standalone Deployment Engine.

The inclusion of a standalone and redistributable deployment engine makes it possible to deploy the output of your database projects (.DBSCHEMA files) to a target database without the need of having Visual Studio Team System Database Edition installed. This enables key scenarios like the inclusion of database schema deployment as part of your application installation.

Get it now :)

Download page
http://www.microsoft.com/downloads/details.aspx?FamilyID=bb3ad767-5f69-4db9-b1c9-8f55759846ed&displaylang=en
Setup
http://download.microsoft.com/download/0/a/e/0ae1153a-8798-474a-93e6-d19299f37c8b/setup.exe

Read Me
http://download.microsoft.com/download/0/a/e/0ae1153a-8798-474a-93e6-d19299f37c8b/Readme.mht

Documentation:
http://download.microsoft.com/download/0/a/e/0ae1153a-8798-474a-93e6-d19299f37c8b/Documentation.zip

Technorati Tags: VSTS,TFS,Team System,Visual Studio Team System,Database Edition,Visual Studio 2008,Visual Studio 2005,SQL Server,SQL Server 2008,SQL Server 2000,SQL Server 2005

Least opportune time.

Martin Hinshelwood — Thu, 20 Nov 2008 14:43:55 GMT

Here I am slogging my guts out, trying to get TFS Sticky Buddy v2.0 out the door and bang goes the TFS server :(

This is tfs05 on the Codeplex environment. All the others seem to be running OK, but juts my luck the one I am using is the one that is affected, and nothing on the Outage page! its been 3 hours and nothing. I have emailed them and reported it on the Discussions page.

Now, although I am, I am not really complaining as they have provided a fantastic service over the last, what… two years!

Hats off to the CodePlex team, but get the bloody server fixed so I can check in my code!

Technorati Tags: TFS,VSTS,Visual Studio Team System,Team Foundation Server,Codeplex,TFS Sticky Buddy

Team Suite on the cheap

Martin Hinshelwood — Tue, 18 Nov 2008 11:23:09 GMT

Ok, so I lied a little. It is not that cheap, but 30% off an upgrade from a team edition to full Team Suit is nothing to be sniffed at, it could be as much as £1000 off!

If your team is using any component edition of Visual Studio Team System 2008 (Development Edition, Test Edition, Architecture Edition, or Database Edition), now’s the time to get more out of your development solution. Step up to the complete Visual Studio Team System 2008 Team Suite, and save 30%. That’s a huge savings to give your development team the full suite of tools - and help them collaborate better than ever during the entire application lifecycle.

Technorati Tags: VSTS,Visual Studio Team System,TFS,TS,Team System