Kentico CMS Mapper functions using Reflection in C# .NET

The following post shows functionality on mapping a Kentico CMS TreeNode object to a strong type .NET model class. These functions use reflection to map a property in a class to a Kentico document type field.

The examples below assumes your Document Types in Kentico have a corresponding .NET model class.

Below is the base class BaseModel that all model classes inherit from:

using CMS.PortalControls;
using CMS.DocumentEngine;
using CMS.CMSHelper;
using CMS.SettingsProvider;

public abstract class BaseModel
{
    // define document id
    public int id
    {
        get { return Document == null ? 0 : Document.DocumentID; }
    }

    // define node id
    public int NodeId
    {
        get { return Document != null ? Document.NodeID : 0; }
    }

    // define name
    public string DocumentName
    {
        get { return Document != null ? Document.DocumentName : ""; }
    }

    // define url
    public string URL
    {
        get { return Document == null ? "" : Document.RelativeURL.Replace("~",""); }
    }

    // define url with extension
    public string URLWithExtension
    {
        get { return URL + (Document == null ? "" : Document.DocumentExtensions); }
    }

    // external url
    public string ExternalURL
    {
        get { return Document == null ? "" : Document.AbsoluteURL; }
    }        

    // path for searching
    public string Path
    {
        get { return Document == null ? "" : URL + (!URL.EndsWith("/") ? "/" : "") + "%"; }
    }

    // define document
    public TreeNode Document { get; set; }


    // define function that maps extra properties
    public abstract void MapExtras();
}

The following are helper types to define an Image and a Generic Document:

public class Image
{
    // fields
    public string Guid { get; set; }

    // function that checks if an image
    public bool HasImage { get { return !String.IsNullOrEmpty(Guid); } } 

    // define path for the image
    public string Path
    {
        get { return String.Format("/getfile/{0}/img/", Guid); }
    }

    // function that returns the html tag for this image
    public string ToHtml(string alt)
    {
        // check if no guid
        if (String.IsNullOrEmpty(Guid))
            return "";

        // return the html tag for this image
        return String.Format("", Path, alt);            
    }
}

public class GenericDocument : BaseModel
{
    public override void MapExtras() { }
}

Below is a generic mapper function to map a given TreeNode and return the requested type:

public static T MapTo(TreeNode document)
    where T : BaseModel, new()
{
    // init item
    T item = new T();

    // check if a document passed
    if (document != null)
    {
        // set the document
        item.Document = document;

        // go through each of this model's properties
        foreach (var p in item.GetType().GetProperties())
        {
            // check if a writeable property
            if (p.CanWrite)
            {
                // check primitive types
                if (p.PropertyType == typeof(string))
                {
                    p.SetValue(item, document.GetStringValue(p.Name, ""), null);
                }
                else if (p.PropertyType == typeof(int))
                {
                    p.SetValue(item, document.GetIntegerValue(p.Name, 0), null);
                }
                else if (p.PropertyType == typeof(bool))
                {
                    p.SetValue(item, document.GetBooleanValue(p.Name, false), null);
                }
                else if (p.PropertyType == typeof(double))
                {
                    p.SetValue(item, document.GetDoubleValue(p.Name, 0), null);
                }
                else if (p.PropertyType == typeof(Guid))
                {
                    p.SetValue(item, document.GetGuidValue(p.Name, new Guid()), null);
                }
                else if (p.PropertyType == typeof(DateTime))
                {
                    p.SetValue(item, document.GetDateTimeValue(p.Name, DateTime.Parse("1/1/1900").Date), null);
                }

                // check complex types
                else if (p.PropertyType == typeof(Image))
                {
                    p.SetValue(item, new Image { Guid = document.GetStringValue(p.Name, "") }, null);
                }                
                else if (p.PropertyType == typeof(GenericDocument))
                {
                    p.SetValue(item, MapTo(GetDocumentFromGUID(document.GetStringValue(p.Name, ""))), null);
                }            
            }
        }

        // map extras
        item.MapExtras();
    }

    // return the item
    return item;
}

Below is a generic mapper function to map a given TreeNodeDataSet and return a list of the requested type:

public static List MapToList(TreeNodeDataSet documentList)
    where T : BaseModel, new()
{
    // define return list
    List list = new List();

    // check if a document list
    if (documentList != null)
    {
        // go through each
        foreach (var n in documentList)
        {
            list.Add(MapTo(n));
        }
    }

    // return 
    return list;
}

Below are helper functions needed for mapping:

// function that gets a tree node from guid
public static TreeNode GetDocumentFromGUID(string guidStr)
{
    // check if no guid
    Guid guid;
    if (Guid.TryParse(guidStr, out guid))
    {
        // get a tree provider
        var th = new TreeProvider();

        // find the node
        var n = th.SelectSingleNode(guid, CultureCode, CMSContext.CurrentSiteName);

        // check if a node
        if (n != null)
        {
            return DocumentHelper.GetDocument(n, th);
        }
    }

    // if here, return nothing
    return null;
}

// function that gets a tree node from id
public static TreeNode GetDocumentFromID(int id)
{
    // check if no id            
    if (id > 0)
    {
        // get a tree provider
        var th = new TreeProvider();
        return DocumentHelper.GetDocument(id, th);                
    }

    // if here, return nothing
    return null;
}

// function that trys to find the current culture, falls back to default
public static string CultureCode
{
    get
    {
        // return nothing if blank
        return CMSContext.CurrentDocumentCulture == null ? "en-US"
            : CMSContext.CurrentDocumentCulture.CultureCode;
    }
}

Below is an example on using this functionality:

// blog post model
public class BlogPost : BaseModel
{
    // fields
    public int BlogPostID { get; set; }
    public string Title { get; set; }
    public DateTime PostDate { get; set; }
    public string PostURL { get; set; }
    public Image Photo { get; set; }
    public string Author { get; set; }
    public string AuthorURL { get; set; }
    public string ReadMoreText { get; set; }

    public override void MapExtras()
    {
    }
}

// example
public class Example
{
    public static void GetSinglePost()
    {
        // get a single post from the current document
        BlogPost post = Mapper.MapTo(CurrentDocument);                
    }

    public static void GetPostList()
    {
        // get a list of blog posts in the path        
        var th = new TreeProvider();

        // find the nodes
        var nodes = th.SelectNodes(
            CMSContext.CurrentSiteName, "/%",
            Globals.CultureCode, false,
            "EXAMPLE.BlogPost", "", "NodeOrder", -1, true, -1);

        // get the list            
        List posts = Mapper.MapToList(nodes).OrderBy(x => x.Document.NodeOrder).ToList();
    }
}