Mike Nichols - Son Of Nun Technology

SQL Quickie - Fix case

Michael Nichols — Fri, 27 Mar 2009 17:07:11 GMT

I needed to quickly (and dirtily) transform rows which were all upper case into pascal cased, so 'I AM OPIE' become 'I Am Opie'.

Here's something I found and ported to a sql function:

CREATE FUNCTION [dbo].[Casing]
(@instring VARCHAR(255))
RETURNS varchar(1000) AS
BEGIN
    --usage: SELECT dbo.Casing('I AM A DOG')
    DECLARE @strptr INT
    DECLARE @strChar char(1)
    DECLARE @outstring varchar(1000)
    SET @outstring = ''
    SET @strptr = 0
    WHILE @strPtr < len(RTRIM(@instring))
    BEGIN
    SET @strptr = @strptr + 1
    SET @strchar = SUBSTRING(@instring,@strptr,1)
    IF @strptr = 1
    SET @outstring = UPPER(@strchar)
    ELSE
    IF SUBSTRING(@instring,(@strptr - 1),1) = ' '
    or SUBSTRING(@instring,(@strptr - 1),1) = ''''
    SET @outstring = SUBSTRING(@outstring,1,@strptr) +
    UPPER(@strchar)
    ELSE
    SET @outstring = SUBSTRING(@outstring,1,@strptr) +
    LOWER(@strchar)
    END
    RETURN @outstring
END

Is Excessive Mapping Of DTOs/ViewObjects to Entities A Code Smell

Michael Nichols — Thu, 05 Mar 2009 07:15:06 GMT

A recent paradigm shift I have been trying to make is to using messaging patterns in my project. One impact of this shift has been a more granular approach to various commands against the domain which somehow changes its state. While I do my best to stick to DDD (Domain Driven Design) modeling patterns and concepts I confess I slide into a CRUD based approach to various actions in the system - lots of data in, lots of data out. This is partly due to the nature of the requirements and partly due to lack of creative thinking regarding what business rules should be enforced on the domain.

As I started to examine where my weak points were in my application I realized I was doing an awful lot of mapping between view objects and domain entities within the Application Service layer which was being called by my Controllers in the web app. This is fine for simple cases but collections of value objects or cross-aggregate references can soon result in too much conditional or procedural code. Then I came across this post by Udi Dahan about getting away from CRUD mentality into a more DDD approach. I had read this before but I didn't "get" it so much. Particularly revealing to me was in the comments where Udi explains a method which is returning a interface that feels 'fluent'.

When I looked over the stinkier parts of my application service code, I recognized I could be more creative in the API for creating the variant objects within my aggregate roots while simultaneously enforcing object creation rules in the domain where they belong. An example would serve to illustrate better.

Consider how I might set the "SomeOptionalValueObject" property on the aggregate root below. Also, let's introduce a Specification that the implementation of the value object which may be assigned is subject to the 'SomeState' of the aggregate (the aptly named "SomeStateHasToBeSatisfiedSpecification").

class AggRoot
{
    public ValueObjectBase SomeOptionalValueObject {get; }
    public SomeState SomeState{get;}
    public void SetSomeOptionalValueObject(SomeOptionalValueObject obj){
       //some stuff
       SomeValueObject = obj;
    }
}

One of the 'rules' of a Value Object in Domain Driven Design is that only transient references to variant objects may be held. That is, we should treat our aggregate root as the entry point and surface to work on for its state and values contributing that state (ie, 'SomeOptionalValueObject' or 'SomeState' above). This simple discipline acts as a funnel for the rules and integrity for the determined roots in our domain and prevents insanity. :)

So how do we perform this simple act of assigning SomeOptionalValueObject to the root which satisfies our SomeStateHasToBeSatisfiedSpecification?

First we might simply put a factory method on the root to create the value object determined by its state and then pass that into our Setter method above:

class AggRoot
{
    //snip
    public ValueObjectBase CreateSomeValueObject(int count,string name, long expectation,TimeSpan duration,/*loads more params*/)
    {
        //some creation logic
        return valueObj;
    }
}

Or perhaps create the value object from the arguments and set it in the same method.

This works if the value object have a variety of implementations, but gets out of hand if we have even a handful of value objects that require different parameters and types.

public class ValueObjectImpl1 : ValueObjectBase
{
   public class ValueObjectImpl1(int count,string name, double amount){}
}
public class ValueObjectImpl2 : ValueObjectBase
{
   public class ValueObjectImpl2(TimeSpan duration,long expectation){}
}
public class ValueObjectImpl3 : ValueObjectBase
{
   public class ValueObjectImpl3(bool isCoarse,TimeSpan duration, double amount){}
}

If there is only one of these value objects I need to build and add to my aggregate root I might create an interface for a builder that is handed to the client to set the value. The implementation of the builder can enforace the SomeStateHasToBeSatisfiedSpecification for our aggregate root. Additionally this will enforce the signatures of the different value object implementations:

interface IValueObjectBuilder
{
    void AddImpl1(int count,string name,double amount);
    void AddImpl2(TimeSpan duration,long expectation);
    void AddImpl3(bool isCoarse,TimeSpan duration,double amount);
}

class AggRoot
{
    IValueObjectBuilder ForOptionalValueObject(){
        //some conditional logic for determining which builder to return
        return builderImplementation;
    }
}

This simple fluency has replaced any property mapping requirement from a client dto => value object and might look now like this:

public void AddSomeValue(object id,ValueObjectImpl1DTO dto)
{
    var aggRoot = repository.Get(id);
    aggRoot.ForOptionalValueObject()
           .AddImpl1(2,"mike",40.32);
    repository.Update(aggRoot);
}

I think this is intention-revealing but I could see also that the method chain might be confusing while browsing the AggRoot. To improve this I might change this to:

class AggRoot
{
    public void SetValueObject(Action<IValueObjectBuilder> with){
      var builder = GetBuilderBasedOnState();
      with(builder);
      SomeOptionalValueObject = builder.Build();
    }
}

Now I only have one method to deal with an I get the bonus of removing the need for the client to call the 'Build' method without resorting to some explicit operator voodoo. Plus I can pass this builder around to do other work internally before pulling the trigger on the build creation method.

This might seem like alot of work but where this starts to shine (I think) is when collections of value objects which all might require different signatures are expected to be added to an aggregate root in one-shot since they are immutable and the collection itself is immutable.

To do this I simply have to create an ISomeValueObjectCollectionBuilder and change the signature on my Set method:

interface ISomeValueObjectCollectionBuilder
{
   void Add(Action<IValueObjectBuilder> with);
}
class AggRoot
{
   //snip
   public void SetValueObject(Action<ISomeValueObjectCollectionBuilder> with)
   {
     var builder = new SomeValueoBjectCollectionBuilder(this);
     with(builder);
     foreach(var item in builder.Items)
     {
         this.items.Add(item);
     }
   }
}

Now my client can navigate this API:

public void AddSomeValueObjects(Impl1ValueObjectDTO[] dtos)
{
   //get root

   aggRoot.SetValueObjects(collection=>
    {
        foreach(var dto in dtos) {
            collection.Add(item=>item.AddImpl1(/*params from dto*/);
            collection.Add(item=>item.AddImpl1(/*params from dto*/);
            collection.Add(item=>item.AddImpl1(/*params from dto*/);
            collection.Add(item=>item.AddImpl1(/*params from dto*/);
         }
    }
}

This simple fluency, along with smarter root factory methods, completely eliminated my need for mappers from DTO objects to their domain variants. Also I found it much simpler to apply specifications on the incoming data AND made creation of these value objects easier to test since it wasn't based on some conditional logic in the service layer. Furthermore, it seems to succeed in meeting the goal of limiting the clients to holding references to the Aggregate Root.

This is of course just one way of enforcing integrity in the domain while translating data from some client in our Application Services using an API that is understandable. A Visitor pattern might be employed to map data based on the IBuilder interface returned by the aggregate root as well without violating separation...but that is another day.

If there are objections to this or perhaps other approaches I'd love to hear them in the comments.

MonoRail 404 Woes

Michael Nichols — Sun, 21 Dec 2008 05:37:51 GMT

Dear Mike In The Future,

If it's been a while since setting up a MonoRail app from ground up, please remember to reference the following assemblies in your web project or at least include them in the /lib folder:

Castle.Components.Common.EmailSender
Castle.Components.Common.TemplateEngine
Castle.Components.Common.Validator
Castle.Components.Common.Binder
Castle.Components.Common.WindsorExtension

Otherwise, you might get a 404 and be confused and consider kicking the nearest small mammal.

Thanks, have a great night.

Mike

Ordering Form Collection Parameters For MonoRail using jQuery

Michael Nichols — Wed, 26 Nov 2008 06:37:42 GMT

On my current app we are using ajax heavily for updating forms, often with the response getting injected into an table or unordered list. The entire form is then posted for the action which will actually change state in the domain.

For example, say we have a 'NewItem' form (and have several properties):

With the action on the controller:

public void myaction([DataBind("newItem")] ItemDTO item)
{
PropertyBag["item"] = item;
RenderView("ViewWithSophisticatedFormattingForItems");
}

This simply pushes back an item using the data provided and jquery appends the table with:

The client will toggle between 'readonly' and 'edit' modes to change data inline.

So this would result in multiple rows of 'item.Name' and 'item.Phone', etc. and the DataBinder will choke if you try this:

public void UpdateToDomain([DataBind("item")] List<ItemDTO> items)
{
//do stuff in domain
}

As magical as MonoRail and her SmartDispatcherController is, she has to know which value belongs to which item in a collection. The lack of indices in the params will therefore cause arrays of 'Value's for a single ItemDTO instance.

My first thought was to do a custom implementation of IParameterBinder + DataBinder combo that parses out the params and tries to split them into multiple instances. This is too difficult though since not all fields may be present for an instance.

So to keep the items in a collection (like table rows or unordered lists) nicely indexed, I created a plugin that handles all the form elements for me. After ajax calls that load data into a table or ul, I can just call the plugin on the rows and all forms elements remain in their appropriate order. Similarly I can unindex forms for posting in the format the action expects. I can similarly just reorder indexes.

This just preserves the id and name convention used throughout monorail (with "_" and "[index]" delimiters respectively). It also changes the 'for' attribute on the label elements for fun.

This is chainable.

To use:

$("table.specimens > tbody tr.edit").indices("on"); //index all rows with class 'edit'
$("table.specimens > tbody tr.edit").indices("off"); //remove index on all rows with class '.edit'
$("table.specimens > tbody tr.edit").indices("ordered"); //ordered existing indices
$("table.specimens > tbody tr.edit").indices();//toggle indexed/nonindexed mode
//specify the parameterName prefix if you are indexing on a nested collection
$("table.specimens > tbody tr.edit").indices("on",{parameterName:'mainclass.nestedObjects'});
//customize whether a new row should increment the index (default is to skip increments on items with class 'repeat-index')
$("table.specimens > tbody tr.edit").indices("on",{isRepeatedIndex:function(){...});

And the plugin:

/***indices plugin for ordering form elements in a group
    @mode (String) :
        "on" (index elements if not already indexed),
        "off" (unindex elements if already indexed),
        "toggle" (toggle between "on" and "off" modes),
        "ordered" (reorder indices of indexed items, or )
    @options (hash) :
        @parameterName (String) : the parameter name to index; if empty, uses the 'name' attribute up to the first '.'
        @isRepeatedIndex (predicate[current item]) : return 'true' to repeat the index (for things like hidden rows, etc); default is a class name 'repeat-index'

***/

(function($) {
    $.fn.indices = function(mode, options) {
        mode = mode || "toggle";
        var defaults = {
            parameterName: "[a-zA-Z0-9]+",
            isRepeatedIndex: function(item) { return $(item).is(".repeat-index"); }
        };
        var opt = $.extend(defaults, options);

        var reIndexedName = new RegExp("^(" + opt.parameterName + ")\\[(\\d+)\\]\\.", "gi");
        var reIndexedId = new RegExp("^(" + opt.parameterName.replace(".", "_") + ")_\\d+\\_", "gi");
        var reNonIndexedName = new RegExp("^(" + opt.parameterName + ")\\.", "gi");
        var reNonIndexedId = new RegExp("^(" + opt.parameterName.replace(".", "_") + ")_", "gi");
        var changeStrategy = null;
        var ndx = -1;

        var unindexElement = function(el, ndx) {
            if (el.name) {
                $(el).attr("name", el.name.replace(reIndexedName, "$1."));
            }
            if (el.id) {
                $(el).attr("id", el.id.replace(reIndexedId, "$1_"));
            }
            if ($(el).attr("for")) {
                $(el).attr("for", $(el).attr("for").replace(reIndexedId, "$1_"));
            }
        };

        var indexElement = function(el, ndx) {
            if (el.name) {
                $(el).attr("name", el.name.replace(reNonIndexedName, "$1[" + ndx + "]."));
            }
            if (el.id) {
                $(el).attr("id", el.id.replace(reNonIndexedId, "$1_" + ndx + "_"));
            }
            if ($(el).attr("for")) {
                $(el).attr("for", $(el).attr("for").replace(reNonIndexedId, "$1_" + ndx + "_"));
            }
        };

        var reindexElement = function(el, ndx) {
            if (el.name) {
                $(el).attr("name", el.name.replace(reIndexedName, "$1[" + ndx + "]."));
            }
            if (el.id) {
                $(el).attr("id", el.id.replace(reIndexedId, "$1_" + ndx + "_"));
            }
            if ($(el).attr("for")) {
                $(el).attr("for", $(el).attr("for").replace(reIndexedId, "$1_" + ndx + "_"));
            }
        };
        return this.each(function(idx, item) {
            if (!opt.isRepeatedIndex(item)) {
                ndx++;
            }

            $(this).find(":input,label").each(function() {

                if (!changeStrategy) {
                    //evaluate only once per collection
                    if (!this.name && !this.id) {
                        //nothing to do here
                        return;
                    }
                    changeStrategy = function() { }; //default empty function
                    var isIndexed = this.name ? reIndexedName.test(this.name) : this.id ? reIndexedId.test(this.id) : false;
                    if (mode == "ordered" && !isIndexed) {
                        mode = "on"; //we already do ordered indexing so just use the 'on' mode
                    }

                    if (isIndexed) {
                        if (mode == "off" || mode == "toggle") {
                            changeStrategy = unindexElement;
                        } else if (mode == "ordered") {
                            changeStrategy = reindexElement
                        }
                    } else {
                        if (mode == "on" || mode == "toggle") {
                            changeStrategy = indexElement;
                        }
                    }
                }
                changeStrategy(this, ndx); //fire

            });
        });

    };

I don't like having to scrub the data like this on the client side, but I really can't think of a way to keep parameters being sent valid while still updating data in small chunks without passing indexes back and forth. Any other approaches would be great to hear!

Considerations For Using PostSharp

Michael Nichols — Mon, 24 Nov 2008 07:19:06 GMT

I recently started using PostSharp for implementing AOP into my current project. It's a great project and really simplifies some specifications we have that could have been cumbersome. Introducing this into an environment that is using NAnt and development using TDD took some exploration for me so I thought I'd log some things I had to overcome.

Building from NAnt

I saw that there was an NAnt task created for PostSharp but I either couldn't get it going, or I couldn't find it ( I can't remember). I ended up just using the command line app included with PostSharp, so I have an NAnt target that invokes the utility from within my project default.build file:

A few things to note here. I had to first make a copy of the assembly I am manipulating and rename it with an 'Pre.assemblyname' prefix (or whatever). The dll was getting locked during the build so PostSharp would complain. The output of PostSharp is 'Post.<assemblyname>' and then I copy that after the utility runs. I think I had the same locking issue that forced me to do this.

Notice I am doing everything in my build directory so I had previously copied over all required PostSharp files to do that when I copy all other dependencies:

TDD Becomes Heavy

The compilation times are considerably larger due to the post-compilation magic. When you are used to almost instant feedback in the IDE this starts out as being an irritation then begins to affect how I write my tests - not good. I will probably pull my aspect related tests into their own test assembly and then target assemblies that are actually used in the app will require some kind of environment condition on the PostSharp targets setup in the .csproj files. I haven't resolved the better approach to take to get around this. I know my own tendency toward impatience will cause me to write bad tests, or not at all, if I have to wait for each rebuild to take so long so I need to keep it quick.

Sorry I am so immature

Michael Nichols — Sun, 23 Nov 2008 08:12:47 GMT

From NH user group:

"I have a "pepe" and I know it is not a proxy"

If this doesn't belong in a software developer's adaptation of Napoleon Dynamite, I don't know what would.

Enabling auto-detection of response type in jQuery

Michael Nichols — Wed, 15 Oct 2008 03:40:39 GMT

Sometimes you don't know what type of document the server is going to return, so it would be nice to have the ajax handler deal with the response as the server is directing it to.

JQuery doesn't have this baked in (I have had a ticket for ages there to implement it), but a workaround is to roll your own handler. The data filter that was introduced in the latest round of jquery is useless since you don't have access to the response object (and thus the header) and doing hacky string parsing was brittle. To replace the current handler, just roll your own httpData function that replaces the native function in jquery.

Using jquery 1.2.6 + here is a patch you can add after the jquery reference on your page:

* patch for dynamic evaluation of xhr responseType to set the dataType on jQuery */
jQuery.extend({
httpData: function( xhr, type, s ) {
        var ct = xhr.getResponseHeader("content-type"),
                xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0,
                script = type == "script" || !type && ct && ct.indexOf("script") >= 0,
                json = type == "json" || !type && ct && ct.indexOf("json") >= 0,
                data = xml ? xhr.responseXML : xhr.responseText;

                if ( xml && data.documentElement.tagName == "parsererror" )
                    throw "parsererror";

                // Allow a pre-filtering function to sanitize the response
                // s != null is checked to keep backwards compatibility
                if( s && s.dataFilter )
                    data = s.dataFilter( data, type );

                // If the type is "script", eval it in global context
                if ( script )
                    jQuery.globalEval( data );

                // Get the JavaScript object, if JSON is used.
                if ( json )
                    data = eval("(" + data + ")");

                return data;
    }
});

All this is doing is what it already does with xml response types...it sniffs the response header and handles appropriately. Now I can let my server determine whether I am generating just some javascript snippet that should get evaluated or some markup that should be pushed into the page without requiring my client ajax method to state it explicitly.

SVN revision number discrepancy

Michael Nichols — Sun, 07 Sep 2008 21:38:04 GMT

I use VisualSVN for IDE integration of VS.NET and TortoiseSVN. While working on my build script I noticed that while fetching my svn revision number it was different than what was getting reported after a commit within the ide.

I am hardly source control guru so I wasn't sure what to do to track this down.

Turns out I needed to do an svn up at the root directory to bring the revision numbers back in alignment as I found in this (PDF) doc.

When Flushing Goes Bad: Assigned IDs in NHibernate

Michael Nichols — Wed, 30 Jul 2008 02:24:16 GMT

I have an aggregate root that creates another persistent entity and places it in a collection.

Typically, I try to avoid letting the internal id used within an aggregate boundary seep outside, but for the purpose of mapping the relevant instance to the ui data being sent, I needed to get the id and pass it back to the ui.

Using this mapping on the newly created entity:

<class name="AggregateRoot" table="RootsButNotTheBook">
    <!--snip-->
    <set name="ChildEntities" class="ChildEntity" cascade="all"> <!--more-->
</class>
<class name="ChildEntity" table="ChildEntities">
        <id name="Id" type="Guid" >
            <generator class="assigned"/>
        </id>
        
    <!--more mapping-->

and trying this code:

aggregateRoot.CreateChildEntityAndAddToCollection();
session.Update(aggregateRoot);
session.Flush();

Will get me this NHibernate exception:

NHibernate.StaleStateException: Unexpected row count: 0; expected: 1

Why? Well, inside my ChildEntity creation logic, I am generating an id for the entity so NHibernate thinks that it is a previously persisted entity ... but of course it isn't.

To make this work I change my child entity mapping to :

<class name="ChildEntity" table="ChildEntities">
        <id name="Id" type="Guid" >
            <generator class="assigned"/>
        </id>
        <version name="LastModifiedOn" 
                type="timestamp" 
                column="LastModifiedOn" 
                access="nosetter.camelcase" />
    <!--more mapping-->

Adding the Versioning element to my entity now lets NHibernate know how to deal with the entity as it should and the code now works swimmingly.

The Hibernate documentation states:

A version or timestamp property should never be null for a detached instance, so Hibernate will detact any instance with a null version or timestamp as transient, no matter what other unsaved-value strategies are specified. Declaring a nullable version or timestamp property is an easy way to avoid any problems with transitive reattachment in Hibernate, especially useful for people using assigned identifiers or composite keys!

Therefore I actually used a nullable DateTime on my ChildEntity class, but things seemed to work even when I used a non-nullable DateTime, so I am not sure what I am missing there. Let me know if there are any errors in anything I present here...

jQuery.cascade : Cascading values from forms

Michael Nichols — Sun, 25 May 2008 09:46:00 GMT

First, get it here ...

Please leave commments/questions on jquery google group at : http://groups.google.com/group/jquery-en.

UPDATE: Fixed bug in ajax extension whereby it was holding a reference to previous data params. Also updated to work with jquery 1.2.6 in demo pack.

UPDATE 06-09-2008 : Breaking change: I inverted dependency from child==>parent to allow unique data sources for each target of a cascade. See distribution for details.

A common task is quickly fetching data to respond to changes on web forms. The canonical example is cascading select forms that provide options based on previous selections. However, there are numerous variants of this simple scenario that could be simplified using jquery's plugin pattern. Really, the goal is simple...when something happens on my page, get some data from somewhere and put in something else, with each item looking like I specify.

Being inspired by the awesome autocomplete plugin here, I adapted their compact code and event delegation pattern to create a simple but powerful plugin for cascading form results into their targets.

While the initial goal was simply cascading select lists and being able to chain them together, the event delegation made so simple in jquery quickly expanded the potential.

You can cascade from any kind of element into any other kind of element (for the most part). You can also provide extensions to the plugin easily enough to handle just about anything and it just weighs in at around 100 lines of code. Packed, it's 1.3 kB.

Events

There are only two events, loading.cascade and loaded.cascade triggered. You may specify what event will fire the cascade on the parent element. To bind to the cascade events, use the chained binding syntax common in jquery...this lets the control scale without munging up the options. For a great discussion of this technique see here and here .

Usage

Here are some examples on how to use it:

With all data being json, using the following structure:

{'when':'selectedValue','value':'itemValue','text':'itemText'}

with static list on page:

$('#myChildSelect').cascade('#myParentSelect', {
list: [{'when':'A','value':'A1','text':'A1'},{'when':'B','value':'B1','text':'B1'}],
template: function(item) { return "<option value='" + item.value + "'>" + item.text + "</option>"; },
match: function(selectedValue) { return this.when == selectedValue; }
});

with ajax call (using .ext ):

$('#myChildSelect').cascade('#myParentSelect', {
    ajax: '/my/url/action',    
    template: function(item) { return "<option value='" + item.value + "'>" + item.text + "</option>"; },
    match: function(selectedValue) { return this.when == selectedValue; }
    });

with chained cascading:

$('#myFirstChildSelect').cascade('#myParentSelect', {
ajax: {url: '/my/url/action' },    
template: function(item) { return "<option value='" + item.value + "'>" + item.text + "</option>"; },
match: function(selectedValue) { return this.when == selectedValue; }
});   

$('#mySecondChildSelect').cascade('#myFirstChildSelect', {
ajax: {url: '/my/url/action' },    
template: function(item) { return "<option value='" + item.value + "'>" + item.text + "</option>"; },
match: function(selectedValue) { return this.when == selectedValue; }
});

add a firstOption for optional lists using the loaded.cascade event:

jQuery("#myChildSelect").cascade("#myParentSelect",{    
        timeout: 100,        
        list:  myDataSource,            
        template: function(item) { return "<option value='" + item.Value + "'>" + item.Text + "</option>"; },
        match: function(selectedValue) { return this.When == selectedValue; }         
    })
    .bind("loaded.cascade",function(e,parent) { jQuery(this).prepend("<option value='empty' selected='true'>--Select--</option>");});

The download has a sample page with lots of different setups and usages. Please let me know if you find any bugs or questions. This is my first plugin for jquery so I may be missing some hidden jquery goodness to make the code more elegant.

I will try to get a working demo up soon.

Third Party Libraries Organization

Michael Nichols — Sat, 10 May 2008 04:46:57 GMT

I finally have my CI environment and am wondering what the heck took me so long to take time to get it set up. This has had me looking again at how I set my project folders up. Typically I am using the libraries from Castle/Nhib/Rhino stack and build them all at the same time quite frequently since the Rhino build process simply ROCKS. However I notice everyone putting all their dependencies in separate folders like this:

/lib/Castle
/lib/NHibernate
/lib/Rhino
/lib/...

Personally, I have just thrown all my dependencies in a single /lib folder and haven't come across issues with this. I still keep tools like mbunit or nant in a separate /tools directory.

My /lib directory isn't as pretty organized looking but like I said most of my dependencies are getting rebuilt at the same time anyways. So what advantage am I missing out on by just throwing everything into a single folder? It has made it much simpler for copying assemblies from other builds (I know I could automate that too). Am I being overly simplistic?

Configuring IIS 6.0 to send mail via SMTP for asp.net applications

Michael Nichols — Thu, 08 May 2008 05:29:21 GMT

Enabling smtp services for IIS is well documented, but configuring in my environment was more difficult than I would have thought it would be... So this post is partly a note for me as we will be changing out gear soon.

Our environment is not very exotic...a box acting as an web server, and another box acting as an exchange server. Both are running Win2003.

First, smtp services must obviously be enabled/running. Here is how.

Next, in IIS, select the new SMTP Virtual server node and right-click/Properties/Access/Relay. Be sure 'Only the list below' is selected and add '127.0.0.1' (localhost) to your Computers Access list . Finally, deselect 'Allow all computers which successfully authenticate...'. Be very careful not to turn your server into a relay server unless you like being blacklisted .

Now, at this point I was able to get my mail sent to domains outside my own. So if my webserver was webbox.mydomain.com and it sent mail to mygmail@gmail.com then all worked just fine. But I was unable to send mail internally to other mail accounts (mydomain.com).

What I failed to do was set up a SMART HOST to route mail to my exchange box.

To do that, right-click the smtp node in iis/Properties/Delivery/Advanced. Enter the name of the server hosting exchange and deselect 'attempt direct delivery before sending to smart host'.

Unobtrusive Growl Messaging Using Monorail Filter

Michael Nichols — Thu, 01 May 2008 07:51:35 GMT

A clever plugin for jquery recently was released which is an impression of Mac's Growl. It simply displays messages for a period of time or makes them 'sticky'. It also manages multiple messages at a time very nicely and all the styling is external so a real snap to customize. The best part is how simply it is implemented. You simply call

jQuery.jGrowl(\"My Message Should Appear\", options );

and you get a popup that gradually fades. Fire off two in quick succession and jgrowl is smart enough to fade them appropriately and provide a global 'close' bar to clear all messages.

On all projects it seems like the most messages I need to communicate to my users lump into similar categories; 'errors','warnings','messages','success','failure', and so on. Typically these are thrown in either a Flash or PropertyBag collection for consumption by the view.

I wanted to simplify how I am passing messages to my users regardless of the request type (Ajax/Non) and regardless of whether I use JS Generation to render some view , so I narrowed down to requiring some filter which would handle all calls and inspect specific collections that I can configure that may or may not be populated with messages during the action. This will either append the messages to our http response directly, or using an TransformFilter implementation (an HttpFilter) - more on that later. Using a filter this way let's me avoid having to drop anything on my layout or require any kind of view code. I simply attach this filter to my controller base and it just works.

First, let's determine what our notifications are:

public class GrowlNotification 
    { 
        private readonly string key = string.Empty; 
        private IDictionary options; 

        public GrowlNotification(string key) 
            : this(key, new HybridDictionary()) 
        { 
        } 

        public GrowlNotification(string key, IDictionary options) 
        { 
            this.key = key; 
            this.options = options; 
        } 

        public string Key 
        { 
            get { return key; } 
        } 

        public IDictionary Options 
        { 
            get 
            { 
                options = options ?? new HybridDictionary(); 
                HybridDictionary defaultOptions = new HybridDictionary(); 
                defaultOptions.Add("sticky", "false"); 
                defaultOptions.Add("theme", "\""+GetTheme()+"\""); 
                defaultOptions.Add("speed", "\"slow\""); 
                CommonUtils.MergeOptions(options, defaultOptions); 
                return options; 

            } 
        } 
        private string GetTheme() 
        { 
            if(string.IsNullOrEmpty(key)) 
            { 
                return "default"; 
            } 
            return key; 
        } 

    }

'Key' is simply a corresponding value with the key of the Flash/PropertyBag being inspected by the Filter after the action. jGrowl lets us pass a 'theme' to attach an additional class name to the message container on the client side so it is real easy to modify how each message appears using simple css. This will correspond with the 'Key' name.

Options are obviously the js options jgrowl supports. Each message type can have its own options. So you can, for example,make 'errors' sticky and all other message types fade out after a bit.

Now, let's encapsulate the configuration and make it accessible on the container but provide an sensible default configuration. This configuration will create the GrowlNotifications for the IGrowlGenerator at runtime:

public interface IGrowlConfiguration 
{ 
    /// <summary> 
    /// Gets the notifications to inject. 
    /// </summary> 
    /// <returns></returns> 
    IEnumerable<GrowlNotification> GetNotifications(); 
    /// <summary> 
    /// Determines whether this the current request is an xhr. 
    /// </summary> 
    /// <returns> 
    ///     <c>true</c> if this instance is ajax; otherwise, <c>false</c>. 
    /// </returns> 
    bool IsAjax(); 
}

'IsAjax()' simply informs the filter of the request type so that it can handle the response message(s) appropriately. This can be simply sniffing the headers, or using a more elaborate extension I wrote but is outside the scope here.

Now it's default implementation:

/// <summary> 
    /// Default configuration for keys <see cref="GrowlFilter"/> will  sniff to inject. It assumes 'errors' and 'success' 
    /// are intended message keys. 
    /// </summary> 
    public class DefaultGrowlConfiguration : IGrowlConfiguration 
    { 
        public virtual IEnumerable<GrowlNotification> GetNotifications() 
        { 
            HybridDictionary errorOptions = new HybridDictionary(); 
            errorOptions.Add("sticky", "true"); 

            return new GrowlNotification[] 
                { 
                    new GrowlNotification("errors", errorOptions), 
                    new GrowlNotification("success"), 
                    new GrowlNotification("failure",errorOptions), 
                    new GrowlNotification("message"), 
                }; 
        } 

        /// <summary> 
        /// Determines whether this the current request is an xhr.  This assumes the <see cref="AjaxRequestExtension"/> is being 
        /// used for request evaluation at runtime. 
        /// </summary> 
        /// <returns> 
        ///     <c>true</c> if this instance is ajax; otherwise, <c>false</c>. 
        /// </returns> 
        public virtual bool IsAjax() 
        { 
            object isAjax = MonoRailHttpHandlerFactory.CurrentEngineContext.Flash[AjaxRequestExtension.IsAjaxKey]; 
            if (isAjax != null) 
            { 
                return (bool) isAjax; 
            } 
            return false; 
        } 
    }

Next, we'll separate out how the jgrowl is generated and provide a default implementation. This will be delegated to within the Filter to write the actual javascript using the configuration:

public interface IGrowlGenerator 
{ 
    string GenerateFrom(IEngineContext context, IController controller, IControllerContext controllerContext); 
} 
public class DefaultGrowlGenerator : IGrowlGenerator 
{ 
    private readonly IGrowlConfiguration growlConfiguration; 

    public DefaultGrowlGenerator(IGrowlConfiguration growlConfiguration) 
    { 
        this.growlConfiguration = growlConfiguration; 
    } 

    public string GenerateFrom(IEngineContext context, IController controller, IControllerContext controllerContext) 
    { 
        if( growlConfiguration == null ) 
        { 
            throw new ArgumentNullException("growlConfiguration"); 
        } 
        StringBuilder scriptContents = new StringBuilder(); 
        bool hasContent = false; 
        IEnumerable<GrowlNotification> notifications = growlConfiguration.GetNotifications(); 
        foreach (GrowlNotification item in notifications ?? new GrowlNotification[0]) 
        { 
            //look in property bag first for message 
            object propBagMsg = controllerContext.PropertyBag[item.Key]; 
            object flashMsg = context.Flash[item.Key]; 
            string msg = string.Empty; 
            if (propBagMsg != null) 
            { 
                msg = msg + propBagMsg ?? string.Empty; 
            } 
            if (flashMsg != null) 
            { 
                msg = msg + flashMsg ?? string.Empty; 
            } 

            if (!string.IsNullOrEmpty(msg)) 
            { 
                hasContent = true; 
                string options = AbstractHelper.JavascriptOptions(item.Options); 
                scriptContents.AppendFormat("jQuery.jGrowl(\"{0}\", {1} );", msg, options); 
            } 
        } 
        if (hasContent) 
        { 
            string inner = JSUtils.WrapWithTryCatch(scriptContents.ToString()); 
            return "jQuery(document).ready(function() { " + inner + "});"; 
        } 
        return string.Empty; 
    } 

}

It's worth noting here that this assumes you are expecting the dataType of 'script' in your jquery ajax calls. I set a global using

$.ajaxSetup({ dataType:"script" });//all calls are returned as js to evaluate

We can finally implement an Monorail filter that will consume all these services and write the appropriate javascript to our response for jgrowl to handle. Here's the filter:

public class GrowlFilter : Filter 
{ 
    private bool prependToBodyCloseTag = false; 
    private string growl = string.Empty; 
    private IGrowlConfiguration growlConfiguration = new DefaultGrowlConfiguration(); 
    private IGrowlGenerator growlGenerator; 
    private ModifyResponse responseModifier; 

    /// <summary> 
    /// Gets or sets the growl configuration. 
    /// </summary> 
    /// <value>The growl configuration.</value> 
    public virtual IGrowlConfiguration GrowlConfiguration 
    { 
        get { return growlConfiguration; } 
        set { growlConfiguration = value; } 
    } 


    /// <summary> 
    /// Gets or sets the response modifier. 
    /// </summary> 
    /// <value>The response modifier.</value> 
    public virtual ModifyResponse ResponseModifier 
    { 
        get 
        { 
            if(responseModifier==null) 
            { 
                responseModifier = DoPrependBodyCloseTag; 
            } 
            return responseModifier; 
        } 
        set { responseModifier = value; } 
    } 

    /// <summary> 
    /// Gets or sets the growl generator. 
    /// </summary> 
    /// <value>The growl generator.</value> 
    public IGrowlGenerator GrowlGenerator 
    { 
        get 
        { 
            if(growlGenerator==null) 
            { 
                if(growlConfiguration==null) 
                { 
                    throw new ArgumentNullException("growlConfiguration","GrowlConfiguration must assigned before creating the DefaultGrowlGenerator. "); 
                } 
                growlGenerator = new DefaultGrowlGenerator(growlConfiguration); 
            } 
            return growlGenerator; 
        } 
        set { growlGenerator = value; } 
    } 


    /// <summary> 
    /// Gets a value indicating whether to prepend to body close tag, as in the case of a standard request. 
    /// </summary> 
    /// <value> 
    ///     <c>true</c> if [prepend to body close tag]; otherwise, <c>false</c>. 
    /// </value> 
    public virtual bool PrependToBodyCloseTag 
    { 
        get { return prependToBodyCloseTag; } 
    } 

    /// <summary> 
    /// Override this method if the filter was set to 
    /// handle <see cref="F:Castle.MonoRail.Framework.ExecuteWhen.AfterAction"/> 
    /// </summary> 
    /// <param name="context">The MonoRail request context</param> 
    /// <param name="controller">The controller instance</param> 
    /// <param name="controllerContext">The controller context.</param> 
    protected override void OnAfterAction(IEngineContext context, IController controller, 
                                          IControllerContext controllerContext) 
    { 
        if (growlConfiguration == null) 
        { 
            throw new ArgumentNullException("growlConfiguration", 
                                            "Growl requires either an implementation of IGrowlConfiguration in the container, or using the DefaultGrowlConfiguration without any registration."); 
        } 
        if( GrowlGenerator == null) 
        { 
            throw new ArgumentNullException("growlGenerator"); 
        } 
        growl = GrowlGenerator.GenerateFrom(context, controller, controllerContext); 

        if (growlConfiguration.IsAjax()) 
        { 
            //this is an xhr so assume jquery.ajax is expecting dataType:'script' and write javascript to stream 
            if (controllerContext.SelectedViewName !=null && !controllerContext.SelectedViewName.EndsWith("js")) 
            { 
                controllerContext.SelectedViewName = null; 
            } 
            context.Response.Output.Write(growl); 
        } 
        else 
        { 
            prependToBodyCloseTag = true; 
        } 
         
    } 
    /// <summary> 
    /// Does the prepending to the body close tag. 
    /// </summary> 
    /// <param name="responseText">The response text.</param> 
    /// <returns></returns> 
    public virtual string DoPrependBodyCloseTag(string responseText) 
    { 
        return responseText.Replace("</body>", AbstractHelper.ScriptBlock(growl) + "</body>"); 
    } 
    /// <summary> 
    /// Override this method if the filter was set to 
    /// handle <see cref="F:Castle.MonoRail.Framework.ExecuteWhen.AfterRendering"/> 
    /// </summary> 
    /// <param name="context">The MonoRail request context</param> 
    /// <param name="controller">The controller instance</param> 
    /// <param name="controllerContext">The controller context.</param> 
    protected override void OnAfterRendering(IEngineContext context, IController controller, 
                                             IControllerContext controllerContext) 
    { 
        if (prependToBodyCloseTag) 
        { 
            context.UnderlyingContext.Response.Filter = 
                new ModifyResponseFilter( context.UnderlyingContext.Response.Filter,ResponseModifier); 
        } 
    } 
}

After the action, this filter determines whether to write the javascript directy to the response in the event of an ajax call, or whether to use an HttpFilter to prepend the javascript to the </body>. Here's the httpfilter being used to modify response output.It accepts an delegate that I can override in my filter if I want the javascript to appear somewhere else on my page:

/// <summary> 
/// Delegate for modifying the contents of the response. Passes in the current response text for manipulation and 
/// requires the final response to be write back into the stream. 
/// </summary> 
public delegate string ModifyResponse(string responseText); 
/// <summary> 
/// For intercepting the response and manipulating it with the <see cref="ModifyResponse"/> passed in. 
/// </summary> 
public class ModifyResponseFilter : TransformFilter 
{ 
    private readonly ModifyResponse responseModifier; 

    /// <summary> 
    /// Initializes a new instance of the <see cref="ModifyResponseFilter"/> class. 
    /// </summary> 
    /// <param name="baseStream">The base stream.</param> 
    /// <param name="responseModifier">The response modifier.</param> 
    public ModifyResponseFilter( Stream baseStream, ModifyResponse responseModifier):base(baseStream) 
    { 
        this.responseModifier = responseModifier; 
    } 

    public override void Write(byte[] buffer, int offset, int count) 
    { 
        if (Closed) throw new ObjectDisposedException("ModifyResponseFilter"); 
        if(responseModifier== null) 
        { 
            throw new ArgumentNullException("responseModifier"); 
        } 
        //Get a string version of the buffer 
        string content = responseModifier(Encoding.Default.GetString(buffer, offset, count)); 

        byte[] newOutput = Encoding.Default.GetBytes(content); 
        BaseStream.Write(newOutput, 0, newOutput.Length); 
    } 
}

Finally here's a screenshot of it in action after an ajax call. During the call I had placed a message in Flash["success"] and now it is displaying (in the gray box) that message to my user without me having to handle anything on the client side or write any view code. Simple.

Hopefully this provides some ideas on how to communicate with users about actions they perform.

Solo A Pensoso

Michael Nichols — Thu, 24 Apr 2008 06:52:53 GMT

Jimmy Bogard has a post that hits the nail on the head with being a lonely programmer yet still applying TDD. I have been asked by two separate people recently what resources they should consider looking into for starting out in programming. Even though I am hardly an authority, I inevitably encourage folks just now getting into it to start learning how to apply TDD. Here are a few other benefits which I see TDD bringing to the solo developer.

Refactoring is encouraged instead of rewriting . Having the freedom to do with the code what I want would usually leave the door of rewriting open to me. This not only stunts my growth as a developer who needs to learn to write code that is malleable, but also costs lots of money. But without tests in place, the paranoia would sometimes drive me to do a rewrite since the old code just didn't look perfect.
BUFD (Big Up Front Design) has a greater chance to be suppressed. One of the problems with working alone is the freedom to think big about all the neat things I could do rather than solving how to execute the project requirements. Since there isn't someone sitting their making a face because you are off-topic on a requirement, the humble [Test] acts as that face that isn't impressed by my gold-plated code.
Programming remains fun because it is doing stuff. Since there aren't the interesting discussions with peers or a sense of teamwork, the neat feeling we get when we see the computer doing our bidding serves to maintain some inspiration for the task-at-hand. If you are having to run the debugger and fight your way through a million NullRef exceptions or other misteaks to get to the point where you see something happening it is easy to get sidetracked or stop having fun. The feedback loop is more important for my sanity than the projects' success.
I am still learning. Working in small chunks seems to promote experimentation in me more than a big empty project template. If there are things I need to play around with I feel like it is easier and okay to do that within a test fixture...I realize this isn't 'TDD' in the sense of driving out my design using tests, but it nonetheless gives me the impression that I am free play around with something before I head the design that way.
Parameters are liberating. Stravinsky once said 'The more constraints one imposes, the more one frees one's self. And the arbitrariness of the constraint serves only to obtain precision of execution.' I have found the simple constraint of getting a test to pass drives me to improvise more in making it do so, usually making me think more creatively.

All I know is that I wasn't delivering features to my clients with as much confidence or timeliness before I started applying the principles the people who advocate TDD do. It isn't simply a matter of being disciplined, because I was quite disciplined, but I needed to focus that discipline into an paradigm that fed me as much as I feed it. For this solo pilot, TDD has scratched that itch.

MonoRail on IIS7 Redux : Configuration And Routing

Michael Nichols — Thu, 03 Apr 2008 06:25:02 GMT

A while ago I posted on the very basics about using Monorail on IIS7. Implementing the routing module requires a bit more tuning though so I wanted to quickly post my configuration and some things to look for if you are having difficulty getting routing going on Monorail. This is mostly to help those googling and to put all this stuff in one place.

First, the configuration which Adam Tybor was gracious enough to help me with:

<configuration>
<!--...-->
<system.webServer>
        <modules>
            <add name="routingEx" type="Castle.MonoRail.Framework.Routing.RoutingModuleEx,Castle.MonoRail.Framework" preCondition="managedHandler" />
            <add name="PerRequestLifestyle" type="Castle.MicroKernel.Lifestyle.PerWebRequestLifestyleModule,Castle.MicroKernel" preCondition="managedHandler" />            
        </modules>
        <handlers accessPolicy="Script, Execute, Read">
            <clear />
            <add name="ASPX" path="*.aspx" verb="*" type="System.Web.UI.PageHandlerFactory" resourceType="Unspecified" preCondition="integratedMode" />            
            <add name="Block-Boo" path="*.boo" verb="*" type="System.Web.HttpForbiddenHandler, System.Web" modules="ManagedPipelineHandler" scriptProcessor="" resourceType="Unspecified" requireAccess="Script" preCondition="integratedMode,runtimeVersionv2.0" />
            <add name="Block-Brail-JS" path="*.brailjs" verb="*" type="System.Web.HttpForbiddenHandler, System.Web" modules="ManagedPipelineHandler" scriptProcessor="" resourceType="Unspecified" requireAccess="Script" preCondition="integratedMode,runtimeVersionv2.0" />
            <add name="Block-Brail" path="*.brail" verb="*" type="System.Web.HttpForbiddenHandler, System.Web" modules="ManagedPipelineHandler" scriptProcessor="" resourceType="Unspecified" requireAccess="Script" preCondition="integratedMode,runtimeVersionv2.0" />
            <add name="Monorail-All" path="*" verb="*" type="Castle.MonoRail.Framework.MonoRailHttpHandlerFactory, Castle.MonoRail.Framework" modules="ManagedPipelineHandler" scriptProcessor="" resourceType="Unspecified" requireAccess="Script" preCondition="" />
            
            
        </handlers>
        <validation validateIntegratedModeConfiguration="false" />
    </system.webServer>
</configuration>

If the 'system.webServer' node doesn't look familiar to you, go read the previous post to get up to speed on how IIS7 looks at your config files.

It is important to note that this configuration <clear/>s all the handler mappings from IIS7 and only implements what is required. Not doing so will prevent the routing module from doing it magic...I am still not sure why even after removing my StaticFile handler I was unable to get my routing module to work, but I looked through all the IIS7 trace logs and it appeared one of the many modules mapped by default was preventing RoutingEx from handling the request.

Another important thing to note is that this configuration would pass all requests through the monorail module which obviously will be less-than-optimal for static content. You can read more about implementing a best practice to handle this here . Basically, you are just setting up another website with stripped down handler mappings either on IIS or some faster server to deliver static content. I have loved separating this kind of stuff out of my web projects as it lets me centralize all the common scripts/images AND speed up my sites.

A minor note, too, is that I am passing *.aspx calls to the PageHandlerFactory. This is simply to use some server controls on an aspx page or two I need to use that require normal webforms handling (with ViewState darkness and Event Model Labyrinths ). I'll be posting more on that setup later...

Other Resources: