PDF generator using Asp.Net MVC views as templates

public static class RazorGeneratorMvcStart {
        public static void Start() {
            var engine = new PrecompiledMvcEngine(typeof(RazorGeneratorMvcStart).Assembly) {
                UsePhysicalViewsIfNewer = HttpContext.Current.Request.IsLocal
            };

            ViewEngines.Engines.Insert(0, engine);

            // StartPage lookups are done by WebPages.
            VirtualPathFactoryManager.RegisterVirtualPathFactory(engine);
        }
    }

var viewEngine = ViewEngines.Engines.OfType<PrecompiledMvcEngine>().FirstOrDefault();

Once you have a reference for the view engine then you can access the views with FindView method. And once you have the view you can manipulate it as needed.

As such, when we run into problems with the deployment, after a couple of attempts, I realized that, if it is possible to use the PrecompiledMvcEngine in such a manner, then it shouldn’t be a difference if using RazorViewEngine, the Asp.Net MVC engine. And so it was. As such the entire solution consists of the following 3 things:
 

1. PdfGenerator class: ​

using HiQPdf;
    /// <summary>
    /// A generic PDF generator
    /// Note: HiQPdf can be used free for PDF with up to 3 pages.
    /// </summary>
    public class PdfGenerator : IPdfGenerator
    {
        /// <summary>
        /// Generates a PDF, for a specific view/template
        /// </summary>
        /// <param name="controllerName">Controller owning the view/template</param>
        /// <param name="viewName">The view/template name</param>
        /// <param name="viewModel">The view model for view/template</param>
        /// <returns></returns>
        public byte[] GeneratePdf(string controllerName, string viewName, IPdfTemplateViewModel form)
        {
            var templateService = new TemplateService();
            string documentContent = templateService.RenderTemplate(controllerName, viewName, form);

            // instantiate the HiQPdf HTML to PDF converter
            var htmlToPdfConverter = new HtmlToPdf();
            htmlToPdfConverter.Document.Margins = new PdfMargins(20);
            htmlToPdfConverter.Document.PageSize = PdfPageSize.A4;
            htmlToPdfConverter.Document.PageOrientation = PdfPageOrientation.Portrait;


            // render the HTML code as PDF in memory
            byte[] bytes = htmlToPdfConverter.ConvertHtmlToMemory(documentContent, null);

            return bytes;
        }
    }

2. TemplateService class:

public class TemplateService : ITemplateService
    {       
        /// <summary>
        /// Renders a PDF template, returning the resulting page as a string
        /// </summary>
        /// <param name="controllerName">The controller coresponding to view </param>
        /// <param name="viewName">The template name</param>
        /// <param name="viewModel">The view model for template</param>
        /// <returns></returns>
        public string RenderTemplate(string controllerName, string viewName, IPdfTemplateViewModel viewModel)            
        {
            var routeData = new RouteData();
            routeData.Values.Add("controller", controllerName);
            var controllerContext = new ControllerContext(new HttpContextWrapper(new HttpContext(new HttpRequest(null, "http://google.com", null), new HttpResponse(null))), routeData, new FakeController());

            var viewEngine = ViewEngines.Engines.OfType<RazorViewEngine>().FirstOrDefault();
            if (viewEngine == null)
            {
                throw new InvalidOperationException("Could not get and instance for RazorViewEngine.");
            }

            using (var outputWriter = new StringWriter())
            {
                var viewResult = viewEngine.FindView(controllerContext, viewName, "", false);

                if (viewResult.View == null)
                {
                    throw new TemplateServiceException(string.Format("Failed to render template {0} because it was not found.", viewName));
                }

                var viewDictionary = new ViewDataDictionary<IPdfTemplateViewModel>()
                {
                    Model = viewModel
                };


                try
                {
                    var viewContext = new ViewContext(controllerContext, viewResult.View, viewDictionary, new TempDataDictionary(), outputWriter);

                    viewResult.View.Render(viewContext, outputWriter);
                }
                catch (Exception ex)
                {
                    throw new TemplateServiceException("Failed to render template due to a engine failure", ex);
                }

                return outputWriter.ToString();
            }
        }
    }

pdfGenerator.GeneratePdf("ControllerName", "TemplateViewName", pdfTemplateModel)

III. An additional problem that needed to be solved
 

• Question 1 child question 1: child question answer 1 
• Question 1 child question 2: child question answer 2 

 

    public class QuestionAnswerViewModel
    {
        public QuestionAnswerViewModel()
        { }

        public QuestionAnswerViewModel(Answer answer)
        {
            if (answer.Value.HasValue)
            {
                Answer = answer.Value.Value ? Shared.Label_Yes : Shared.Label_No;
            }
            else if (!string.IsNullOrWhiteSpace(answer.Text))
            {
                Answer = answer.Text;
            }
            Question = answer.Question.Text;            
        }

        public string Answer { get; set; }
        public int Order { get; set; }
        public string Question { get; set; }
        public QuestionAnswerViewModel Successor { get; protected set; }

        public void SetSuccessor(QuestionAnswerViewModel successor)
        {
            Successor = successor;
        }
    }  

This then allows you to call the DisplayTemplate for this class recursively if any of  the questions have a Successor:

@if (Model.Successor != null)
{
  @Html.DisplayFor(m => m.Successor,"QuestionAnswer")
}

If you enjoyed reading this, you can also check the HealthPoint solution.