This is going to be the first of three or four posts around integrating the .Net open source content management system N2CMS into the Sharp Architecture demo application Who Can Help Me?. Who Can Help Me? was born out of our work on Fancy Dress Outfitters, which had N2CMS at its core, however we decided to leave the CMS piece out of WCHM as the application didn’t really need it and we didn’t want to overly complicate things. WCHM already has quite a lot going on – even though it’s a relatively simple application, the idea was to present an architecture reference for an application that would scale and potentially become a lot more complicated.

However, over the last few weeks, a number of people have asked about the approach we took with N2 and ASP.Net MVC on Fancy Dress Outfitters and how we would go about adding N2CMS to WCHM. So, after a brief discussion with the guys, we decided it would be beneficial to create a new branch of WCHM that is backed by N2CMS.

I want these posts to walk through the steps taken and changes made to the solution in order to integrate the CMS. I’m going to write the posts as I’m making the changes, so ideally I’ll be able to link to specific changesets that I check into the branch.

Step 1 – Adding the N2 assemblies

I already had a download of the N2CMS trunk code from here as of a week or two ago as I’m using it again on my current project. I built the solution using the Deploy_Everything-vs2008.bat script, after replacing the System.Data.SQLite.dll for a 64 bit version.

This creates the output folder and deploys the example, templates and edit sites with all the necessary references. I grabbed the necessary dlls and checked them into the ReferencedAssemblies folder under the N2CMS folder.

Changeset reference 54936

Step 2 – Add edit site to web project

I then grabbed the deployed edit site (which is the CMS admin interface) from under one of the template sites in the output folder and added it to a new Edit directory under the WhoCanHelpMe.Web MVC web application project. The edit site is a Web Forms project, however they sit nicely side by side together as when browsing to the .aspx pages of the Web Forms project, the MVC routing knows that it should ignore real existing file requests and so they just get processed as normal.

Another option is to split out the edit site and the public facing website into two separate web projects. This is a good idea as it allows you to deploy the two sites differently. For example, you could set up two separate websites in IIS:

http://www.yoursite.com

http://admin.yoursite.com

and create a virtual directory to the edit site in only the second site:

http://admin.yoursite.com/edit

which is routed to the edit site location. By IP restricting the admin.yoursite.com site in IIS, you are preventing unwanted users from even being able to browse to your edit site url, before the even get chance to log in.

However, this seemed like overkill for the WCHM demo, so I took the easy route and just dropped the edit site into the existing web project.

Changeset reference 54943

Step 3 – Creating initial content definitions

N2 requires a root node and a start node as an initial site skeleton. Each node must be of a particular content type, so we need to start by creating these type definitions in code so that we can set the root and start nodes in both the database and the N2 config section in web.config.

I created two definitions – a SiteRoot:

namespace WhoCanHelpMe.Domain.Cms.Pages
{
    using N2;
    using N2.Details;
    using N2.Installation;
    using N2.Integrity;

    /// <summary>
    /// The site root definition
    /// </summary>
    [PageDefinition("Site Root",
        Description = "A site root used to organize home pages.",
        SortOrder = 0,
        InstallerVisibility = InstallerHint.PreferredRootPage,
        IconUrl = "~/edit/img/ico/png/page_gear.png")]
    [WithEditableTitle("Title", 5, Focus = true, ContainerName = Tabs.Content)]
    [RestrictParents(AllowedTypes.None)]
    public class SiteRoot : AbstractPage
    {
        /// <summary>
        /// Gets site root Url.
        /// </summary>
        /// <value>
        /// The site root url.
        /// </value>
        public override string Url
        {
            get { return "~/"; }
        }
    }
}

And a HomePage:

namespace WhoCanHelpMe.Domain.Cms.Pages
{
    #region Using Directives

    using N2;
    using N2.Details;
    using N2.Installation;
    using N2.Integrity;
    using N2.Web.UI;

    #endregion

    /// <summary>
    /// The home page definition.
    /// </summary>
    [PageDefinition("Home Page",
        Description = "A home page template.",
        SortOrder = 440,
        InstallerVisibility = InstallerHint.PreferredRootPage | InstallerHint.PreferredStartPage,
        IconUrl = "~/edit/img/ico/png/page_world.png")]
    [WithEditableTitle("Title", 5, Focus = true, ContainerName = Tabs.Content)]
    [RestrictParents(typeof(SiteRoot))]
    public class HomePage : AbstractPage
    {
    }
}

Both these definitions inherit from a base AbstractPage:

namespace WhoCanHelpMe.Domain.Cms.Pages
{
    #region Using Directives

    using System.Collections.Generic;
    using System.Security.Principal;
    using N2;
    using N2.Collections;
    using N2.Web.UI;

    #endregion

    /// <summary>
    /// A base class for page items.
    /// </summary>
    [TabContainer(Tabs.Content, "Content", 0)]
    public abstract class AbstractPage : ContentItem, IItemContainer
    {
        #region IItemContainer Members

        /// <summary>
        /// Gets the item associated with the item container.
        /// </summary>
        public ContentItem CurrentItem
        {
            get { return this; }
        }

        #endregion

        /// <summary>
        /// Overridden for performance reasons
        /// to save N2 having to do role based
        /// authorization look ups for each page
        /// </summary>
        /// <param name="user">
        /// The current user.
        /// </param>
        /// <returns>
        /// Always true
        /// </returns>
        public override bool IsAuthorized(IPrincipal user)
        {
            return true;
        }

        /// <summary>
        /// Gets all children of the specified type
        /// of the current item
        /// </summary>
        /// <typeparam name="T">
        /// The type filter
        /// </typeparam>
        /// <returns>
        /// The list of children
        /// </returns>
        public virtual IList<T> GetChildren<T>() where T : ContentItem
        {
            return new ItemList<T>(
                Children,
                new TypeFilter(typeof(T)));
        }
    }
}

Changeset reference 54950

Step 4 – Create database schema

I then added the N2CMS database schema to the solution. As we’re already using the Visual Studio Team System Database Edition, I was able to create a database project easily by pointing the wizard at an existing installation of N2 that I already had. The database can then easily be created by right clicking the database project and selecting deploy.

Without the database project, you’d need to create the database schema manually by running the scripts that N2 provide as part of the download.

Once your database is created, remember to grant the correct permissions to be able to access it (This had me banging my head against the wall for a while!).

Changeset reference 54952

Next

That’s enough for now, we don’t have a working site just yet and there’s still a lot to do, but I want to break this up into manageable chunks and also am writing this as I go along. Next we need to add in our root nodes to the database, register our N2 routes and start to build out the controllers and content definitions….