TemplateService.ServiceStack.cs

using System;
using System.Collections.Generic;
using System.Dynamic;
using ServiceStack.Common;
using ServiceStack.Html;
using ServiceStack.ServiceHost;
using ServiceStack.Text;
using ServiceStack.WebHost.Endpoints.Extensions;

namespace ServiceStack.Razor.Templating
{
    public partial class TemplateService
	{
		/// <summary>
		/// Runs and returns the template with the specified name.
		/// </summary>
		public IRazorTemplate ExecuteTemplate<T>(T model, string name, string defaultTemplatePath=null, 
            IHttpRequest httpReq = null, IHttpResponse httpRes = null)
		{
			if (string.IsNullOrEmpty(name))
				throw new ArgumentException("The named of the cached template is required.");

		    ITemplate instance = GetTemplate(name);
            if (instance == null)
                throw new ArgumentException("No compiled template exists with the specified name.");

			SetService(instance, this);
			SetModel(instance, model);
            TemplateBase.ViewBag = new ExpandoObject();

			var razorTemplate = (IRazorTemplate)instance;
            razorTemplate.Init(viewEngine, new ViewDataDictionary<T>(model), httpReq, httpRes);
	
			instance.Execute();

		    var template = httpReq.GetTemplate();
            if (template != null)
		        template = viewEngine.HasTemplate(template) ? template : null;

            if (template == null && !razorTemplate.Layout.IsNullOrEmpty())
                template = razorTemplate.Layout.MapServerPath();

            if (template == null)
                template = defaultTemplatePath;

            var layoutTemplate = GetTemplate(template ?? RazorFormat.DefaultTemplate);
            if (layoutTemplate != null)
			{
				layoutTemplate.ChildTemplate = razorTemplate;
				SetService(layoutTemplate, this);
				SetModel(layoutTemplate, model);
				layoutTemplate.Execute();

				return layoutTemplate;
			}
            else if (defaultTemplatePath != null)
            {
                throw new ArgumentException(
                    "No template exists with the specified Layout: " + defaultTemplatePath);
            }

			return razorTemplate;
		}

        readonly Dictionary<string, string> pagePathAndNames = new Dictionary<string, string>(StringComparer.CurrentCultureIgnoreCase);

		public void RegisterPage(string pagePath, string pageName)
		{
			pagePathAndNames[pagePath] = pageName;
		}

		public bool ContainsPagePath(string pagePath)
		{
			return pagePathAndNames.ContainsKey(pagePath);
		}
		
		public bool ContainsPageName(string pageName)
		{
			return pagePathAndNames.ContainsValue(pageName);
		}

		public IRazorTemplate GetTemplate(string name)
		{
			ITemplate instance;
			if (!templateCache.TryGetValue(name, out instance))
			{
			    var view = viewEngine.GetView(name);
                if (view == null)
                {
                    if (name == RazorFormat.DefaultTemplate)
                        return null;

                    throw new Exception("Could not find template " + name);
                }
                view.Compile(); //compiling adds to templateCache

			    templateCache.TryGetValue(name, out instance);
			}
			return instance as IRazorTemplate;
		}

		public IRazorTemplate RenderPartial<T>(T model, string name)
		{
			var template = GetTemplate(name);
			SetService(template, this);
			SetModel(template, model);

			//TODO: make less ugly, 
			//since executing templates clears the buffer we need to capture 
			//what's been rendered and prepend after.
			var capture = template.Result;

		    try
		    {
                template.Execute();
            }
		    catch (Exception ex)
		    {
		        throw new InvalidOperationException(
                    "Could not execute partial: " + name + ", model: " + model);
		    }

			template.Prepend(capture);
			
			return template;
		}

	}
}