Fissum Blog

Fissum 0.7 released

Michel Perfetti — Tue, 10 Jun 2008 13:15:25 GMT

You can download it here: http://www.codeplex.com/fissum/Release/ProjectReleases.aspx?ReleaseId=9746. Please remove the previous version before installing the new one.

This is a previous post about the new features : Fissum 0.7 new features

More post are coming about the Fissum API !

Fissum and Team Explorer version

Michel Perfetti — Mon, 09 Jun 2008 17:15:50 GMT

Before releasing the next version of Fissum, I want to precise how Fissum is connected to the Team Explorer. Until now Fissum is linked to the Team Explorer 2005, the next version of Fissum will be shipped for Team Explorer 2008 and 2005 : you will have to choose which version of Fissum you want to install. The Team Explorer installation is still mandatory.

The two versions have the same functionalities but not the same assembly names. In the 2008 version, the end of the assembly names are tagged with a "9" at (related to the version of Visual Studio):

This is done to prevent error while referencing the Fissum API.

Linq to WIQL and Model Generation

Michel Perfetti — Mon, 05 May 2008 10:12:59 GMT

In my last post about Linq to WIQL, I created a query on generic fields on the work item object. Fissum work item class can also be extended to access to specific fields of your work item template. This is the job of model generation tools of the Fissum API. The next version of Fissum comes with two tools: a graphical model selector, and a command line code generation tool. For now, the model selector program does not implement all the functionnalities I want, but for a first version it is quite enough :). The goal of this tool is to generate a xml description of the template. This description is used to generate classes other the work item class by the command line tool:

You also need to provide a namespace for the generated source code. This tool generates the following xml file:

The generation tool takes the classes definition in the xml file to generate classes by using the CodeDom API. This is an example of the generated code in C# but the source code can also be generated in VB.Net:
 
  /// <summary>Work Item definition</summary>
  [Fissum.Core.Linq.ModelTypeAttribute("Work Item")]
  [Fissum.Core.Linq.CreatorProviderAttribute(typeof(WorkItemProvider))]
  public partial class WorkItem : Fissum.TeamSystem.WorkItemObject {
 
    internal WorkItem(Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem workitem, Fissum.TeamSystem.TeamFoundationServer server) : 
        base(workitem, server) {
    }
 
    /// <summary>The person who re-opened the work item</summary>
    [Fissum.TeamSystem.Model.FieldAttribute("Microsoft.VSTS.Common.ActivatedBy")]
    public virtual string ActivatedBy {
      get {
        return this.Field<string>("Microsoft.VSTS.Common.ActivatedBy");
      }
      set {
        this.SetField<string>("Microsoft.VSTS.Common.ActivatedBy", value);
      }
    }
 
    /// <summary>The date and time the work item was re-opened</summary>
    [Fissum.TeamSystem.Model.FieldAttribute("Microsoft.VSTS.Common.ActivatedDate")]
    public virtual System.Nullable<System.DateTime> ActivatedDate {
      get {
        return this.Field<System.Nullable<System.DateTime>>("Microsoft.VSTS.Common.ActivatedDate");
      }
      set {
        this.SetField<System.Nullable<System.DateTime>>("Microsoft.VSTS.Common.ActivatedDate", value);
      }
    }
 
    /// <summary>The person assigned to do the work</summary>
    [Fissum.TeamSystem.Model.FieldAttribute("System.AssignedTo")]
    public virtual string AssignedTo {
      get {
        return this.Field<string>("System.AssignedTo");
      }
      set {
        this.SetField<string>("System.AssignedTo", value);
      }
    }
 
    /// <summary>The person who closed the work item</summary>
    [Fissum.TeamSystem.Model.FieldAttribute("Microsoft.VSTS.Common.ClosedBy")]
    public virtual string ClosedBy {
      get {
        return this.Field<string>("Microsoft.VSTS.Common.ClosedBy");
      }
      set {
        this.SetField<string>("Microsoft.VSTS.Common.ClosedBy", value);
      }
    }
 
    /// <summary>The date and time the work item was closed</summary>
    [Fissum.TeamSystem.Model.FieldAttribute("Microsoft.VSTS.Common.ClosedDate")]
    public virtual System.Nullable<System.DateTime> ClosedDate {
      get {
        return this.Field<System.Nullable<System.DateTime>>("Microsoft.VSTS.Common.ClosedDate");
      }
      set {
        this.SetField<System.Nullable<System.DateTime>>("Microsoft.VSTS.Common.ClosedDate", value);
      }
    }
 
    /// <summary>The priority of the work item</summary>
    [Fissum.TeamSystem.Model.FieldAttribute("CodeStudio.Rank")]
    public virtual string CodeStudioRank {
      get {
        return this.Field<string>("CodeStudio.Rank");
      }
      set {
        this.SetField<string>("CodeStudio.Rank", value);
      }
    }
 
    /// <summary>The description of how the work item was closed</summary>
    [Fissum.TeamSystem.Model.FieldAttribute("CodePlex.ClosedComment")]
    public virtual string CodePlexClosedComment {
      get {
        return this.Field<string>("CodePlex.ClosedComment");
      }
      set {
        this.SetField<string>("CodePlex.ClosedComment", value);
      }
    }
 
    /// <summary>The person who re-opened the work item</summary>
    [Fissum.TeamSystem.Model.FieldAttribute("CodePlex.ReOpenedBy")]
    public virtual string CodePlexReOpenedBy {
      get {
        return this.Field<string>("CodePlex.ReOpenedBy");
      }
      set {
        this.SetField<string>("CodePlex.ReOpenedBy", value);
      }
    }
 
    /// <summary>The person who reported the work item</summary>
    [Fissum.TeamSystem.Model.FieldAttribute("CodePlex.ReportedBy")]
    public virtual string CodePlexReportedBy {
      get {
        return this.Field<string>("CodePlex.ReportedBy");
      }
      set {
        this.SetField<string>("CodePlex.ReportedBy", value);
      }
    }
 
    /// <summary>The person who last updated the work item</summary>
    [Fissum.TeamSystem.Model.FieldAttribute("CodePlex.UpdatedBy")]
    public virtual string CodePlexUpdatedBy {
      get {
        return this.Field<string>("CodePlex.UpdatedBy");
      }
      set {
        this.SetField<string>("CodePlex.UpdatedBy", value);
      }
    }
 
    /// <summary>The number of votes from users</summary>
    [Fissum.TeamSystem.Model.FieldAttribute("CodePlex.UserVotes")]
    public virtual System.Nullable<int> CodePlexUserVotes {
      get {
        return this.Field<System.Nullable<int>>("CodePlex.UserVotes");
      }
      set {
        this.SetField<System.Nullable<int>>("CodePlex.UserVotes", value);
      }
    }
 
    /// <summary>The reason why the work item has the current status</summary>
    [Fissum.TeamSystem.Model.FieldAttribute("System.Reason")]
    public virtual string Reason {
      get {
        return this.Field<string>("System.Reason");
      }
      set {
        this.SetField<string>("System.Reason", value);
      }
    }
 
    /// <summary>The status of the work item</summary>
    [Fissum.TeamSystem.Model.FieldAttribute("System.State")]
    public virtual string State {
      get {
        return this.Field<string>("System.State");
      }
      set {
        this.SetField<string>("System.State", value);
      }
    }
 
    /// <summary>The date and time of the last change to the status</summary>
    [Fissum.TeamSystem.Model.FieldAttribute("Microsoft.VSTS.Common.StateChangeDate")]
    public virtual System.Nullable<System.DateTime> StateChangeDate {
      get {
        return this.Field<System.Nullable<System.DateTime>>("Microsoft.VSTS.Common.StateChangeDate");
      }
      set {
        this.SetField<System.Nullable<System.DateTime>>("Microsoft.VSTS.Common.StateChangeDate", value);
      }
    }
 
    [Fissum.TeamSystem.Model.FieldAttribute("System.WorkItemType")]
    public virtual string WorkItemType {
      get {
        return this.Field<string>("System.WorkItemType");
      }
    }
 
    /// <summary>The type of work item</summary>
    [Fissum.TeamSystem.Model.FieldAttribute("CodeStudio.WorkItemType")]
    public virtual string CodePlexWorkItemType {
      get {
        return this.Field<string>("CodeStudio.WorkItemType");
      }
      set {
        this.SetField<string>("CodeStudio.WorkItemType", value);
      }
    }
  }

The "<summary></summary>" help string containes the same description as the description written is the work item template, so you can use it while you're using your model:

As the generated class inherits from my work item base class, I can use it in the LINQ query:

var q = (from wi in project.Get<Fissum.Model.Codeplex.WorkItem>()
        where wi.CodePlexWorkItemType == "Feature"
        orderby wi.CodePlexUserVotes descending
        select wi
        ).ToList();

This is the generated WIQL query:

SELECT [System.Id]
FROM WORKITEMS
WHERE (([CodeStudio.WorkItemType] = @P0)) AND (System.TeamProject = @project) AND (System.WorkItemType = 'Work Item')
ORDER BY [CodePlex.UserVotes] desc

Where all the "where" tests come from? This is simple:

The first test comes from the query itself
The test on the project is here because the query is query on a projet. You cannot use specialized work item classes directly on a server because each project can have a specific template.
The test "System.WorkItemType = 'Work Item'" is generated from the attribute ModelTypeAttribute of the WorkItem class

In this version, there is no integrity test between the model and the project because it is not as simple as comparing the project template definition with the template used to generate the class source. But I'm working on it :)

RSS URL Issue...

Michel Perfetti — Sat, 03 May 2008 16:33:54 GMT

Fixed :)

Syndication URL error

Michel Perfetti — Wed, 23 Apr 2008 15:16:06 GMT

This is weard: the RSS URL given by Subtext is wrong: "www" is missing. the right one is http://www.fissum.com/blog/Rss.aspx . I'm currently trying to redirect fissum.com to www.fissum.com to patch this issue.

Linq To WIQL

Michel Perfetti — Wed, 23 Apr 2008 13:11:59 GMT

Linq To WIQL is a specific implementation of LINQ to build WIQL request. This C# Linq code:

string searchString = "fissum";
 
var q = (from wi in server.WorkItems()
        where
            wi.Title.Contains(searchString) ||
            wi.History.Contains(searchString) ||
            wi.Description.Contains(searchString)
        orderby wi.CreatedDate descending
        select new { Id = wi.Id, Title = wi.Title, CreatedDate = wi.CreatedDate }
        ).ToList();

is transformed in this WIQL query:

SELECT [System.Id]
FROM WORKITEMS
WHERE ((([System.Title] contains @P0 OR [System.History] contains @P1) OR [System.Description] contains @P2))
ORDER BY [System.CreatedDate] desc

The select clause is not used to generate work item result list by the TFS assembly so I limit it to the minimum.

Linq To WIQL is used by Fissum in the word search feature in the "Quick Go To" window.

In the example the request is server based request, but it can be limited to a specific project. With the Fissum preview, Linq To WIQL comes with model generator tools : these tools creates classes over the WorkItem class of the Fissum API to handle the specific fields of the templates.

Fissum 0.7 new features

Michel Perfetti — Wed, 23 Apr 2008 12:49:38 GMT

Fissum 0.7 development is about to finish, and I what to share with you the new major features of this version:

Window position is stored when they are reopened.

Hierarchical query menu:

You can use any allowed character (for example ",") to create hierarchy in your queries:

History window

The history window stores the last opened or modified work items. It comes with the same functionalities as the query window

Word search in the quick go to form:

You have now two alternatives in the "quick go to" windows:

enter an id and open a single work item
type a word and launch a search for all the work item of the selected server with the word in the title or description :

That's all the the Fissum program itself. Fissum is now based on a API called "Fissum API". This API is not linked to the Fissum itself. It can be used to develop other TFS tools. This API is splitted in several parts:

Fissum.TeamSystem is a direct layer with some enhancement over the TFS API
Fissum.Core is the core assembly. This API exposes a Fissum Context that can be used to exploit the Fissum configuration for other programs and exposes the same configuration for all of them.
Fissum.Core.Windows is a set of user controls over the TFS API like the Work Item control, Work Item List, and a master-detail Work Item list. They exactly are the controls used by Fissum itself.
Fissum.Core.Linq is a implementation of LINQ over the WIQL Language. I'll make a specific post on it.
Model generation tools to generate work item code models over the work item process template. This feature can be used to develop tools dedicated to specific template. This tool is build over Linq to WIQL.

This API is not frozen yet. A preview version will be released with some demo programs with Fissum 0.7

Welcome to the Fissum Blog

Michel Perfetti — Mon, 21 Apr 2008 15:43:02 GMT

Codeplex is a great tool, but not very useful when you need to deliver news about a project. This is why I created this blog. All the news about Fissum: new features, howto... will be posted here. I'll also use this blog to share my experience about Team System development.

Michel Perfetti