public DefaultServerGridLayoutOptions(
     ContextualizedHelpers helpers,
     IList<RowType> rows,
     IList<KeyValuePair<string, string>> toolbars,
     Template<LayoutTemplateOptions> layoutTemplate,
     IEnumerable<Template<LayoutTemplateOptions>> subTemplates, 
     IHtmlContent mainContent,
     GridType type,
     string id,
     string prefix,
     GridErrorMessages messages,
     string cssClass,
     string caption,
     Type localizerType
     ) : base(rows, toolbars, layoutTemplate, subTemplates, mainContent)
 {
     this.helpers = helpers;
     Type = type;
     Messages = messages;
     Id = id;
     Prefix = prefix;
     CssClass = cssClass;
     Caption = caption;
     var first = rows.FirstOrDefault();
     MustAddButtonColumn = first.MustAddButtonColumn(helpers, Type== GridType.Batch);
     VisibleColumns = first.VisibleColumns(helpers, Type == GridType.Batch);
     LocalizerType = localizerType;
     Localizer = LocalizerType != null ? helpers.LocalizerFactory.Create(LocalizerType) : null;
 }

        public ActionResult Create(Template template)
        {
            var templateToCreate = new Template();
            Mapper.Map(template, templateToCreate);
            templateToCreate.Seminar = SiteService.GetLatestSeminar(Site, true);

            ModelState.Clear();
            templateToCreate.TransferValidationMessagesTo(ModelState);
            if (ModelState.IsValid)
            {
                // inactivate all old templates
                foreach (var t in _templateRepository.Queryable.Where(a => a.NotificationType == templateToCreate.NotificationType))
                {
                    t.IsActive = false;
                    _templateRepository.EnsurePersistent(t);
                }

                _templateRepository.EnsurePersistent(templateToCreate);

                Message = "Template Created Successfully";

                return RedirectToAction("Index");
            }

            var viewModel = TemplateViewModel.Create(Repository, templateToCreate);
            return View(viewModel);
        }

 public DefaultServerDetailLayoutOptions(
     ContextualizedHelpers helpers,
     IList<RowType> rows,
     IList<KeyValuePair<string, string>> toolbars,
     Template<LayoutTemplateOptions> layoutTemplate,
     IEnumerable<Template<LayoutTemplateOptions>> subTemplates,
     IHtmlContent mainContent,
     string id,
     string prefix,
     string cssClass,
     Type localizerType,
     bool editMode,
     string formAction,
     string formMethod,
     bool? antiforgery,
     bool noSubmit=false
     ) : base(rows, toolbars, layoutTemplate, subTemplates, mainContent)
 {
     this.helpers = helpers;
     Id = id;
     Prefix = prefix;
     CssClass = cssClass;
     LocalizerType = localizerType;
     Localizer = LocalizerType != null ? helpers.LocalizerFactory.Create(LocalizerType) : null;
     EditMode = editMode;
     Antiforgery = antiforgery;
     FormAction = formAction;
     FormMethod = formMethod;
     NoSubmit = noSubmit;
 }

        public void SetUp()
        {
            var source1 = new TestSource
            {
                Name = "-artist-",
                GetAllItemsFunc = c => new[]
                {
                    new DynamicItem("beatles", new [] { new ContextItem("artist-id", "1") }),
                    new DynamicItem("beach-boys", new [] { new ContextItem("artist-id", "2") })
                }
            };

            var source2 = new TestSource
            {
                Name = "-album-",
                GetAllItemsFunc = c =>
                    {
                        return c.Any(i => i.Name == "artist-id" && i.Value == "1")
                        ? new[] { new DynamicItem("revolver") }
                        : new[] { new DynamicItem("pet-sounds") };
                    }
            };

            var dynamicSourceProvider = MockRepository.GenerateMock<IDynamicSourceProvider>();

            dynamicSourceProvider.Stub(p => p.Get("-artist-")).Return(source1);
            dynamicSourceProvider.Stub(p => p.Get("-album-")).Return(source2);
            var pathInstanceBuilder = new PathInstanceBuilder(dynamicSourceProvider);

            var template = new Template(new[] { "static", "-artist-", "-album-" });
            template.BuildInstancePaths(pathInstanceBuilder);

            this.resource = new TemplateResourceBuilder().Build(template) as TemplateResource;
        }

        /// <summary>
        /// Creates a new session for assembling documents using the HotDocs Cloud Services Rest API.
        /// </summary>
        /// <param name="template">The template to use with the session.</param>
        /// <param name="billingRef">This parameter lets you specify information that will be included in usage logs for this call. For example, you can use a string to uniquely identify the end user that initiated the request and/or the context in which the call was made. When you review usage logs, you can then see which end users initiated each request. That information could then be used to pass costs on to those end users if desired.</param>
        /// <param name="answers">The answers to use.</param>
        /// <param name="markedVariables">An array of variable names, whose prompts should be "marked" when displayed in an interview.</param>
        /// <param name="interviewFormat">The format to use when displaying an interview.</param>
        /// <param name="outputFormat">The format to use when assembling a document.</param>
        /// <param name="settings">The settings to use with the session.</param>
        /// <param name="theme">The interview theme.</param>
        /// <param name="showDownloadLinks">Indicates whether or not links for downloading the assembled document(s) should appear at the end of the interview.</param>
        /// <returns></returns>
        public string CreateSession(
			Template template,
			string billingRef = null,
			string answers = null,
			string[] markedVariables = null,
			InterviewFormat interviewFormat = InterviewFormat.JavaScript,
			OutputFormat outputFormat = OutputFormat.Native,
			Dictionary<string, string> settings = null,
			string theme = null,
			bool showDownloadLinks = true
		)
        {
            return (string)TryWithoutAndWithPackage(
                (uploadPackage) => CreateSessionImpl(
                    template,
                    billingRef,
                    answers,
                    markedVariables,
                    interviewFormat,
                    outputFormat,
                    settings,
                    theme,
                    showDownloadLinks,
                    uploadPackage)
            );
        }

        public void renders_the_template()
        {
            var theValue = TemplateValue.For("field", "FirstName");
            var theTemplate = new Template(StringToken.FromKeyString("Test", "{field} is required"), theValue);

            theTemplate.Render().ShouldBe("FirstName is required");
        }

		public static void InvokeTemplateSelected(TemplateProfile profile, Template oldTemplate)
		{
			if (profile != null && !profile.Deleted && OnTemplateSelected != null)
			{
				OnTemplateSelected(profile, oldTemplate);
			}
		}

        public static TemplateGenerationStatusEventArgs CreateWaiting(Template template)
        {
            if (template == null)
                throw new ArgumentNullException("template");

            return new TemplateGenerationStatusEventArgs(template, GenerationStatus.Waiting);
        }

        public void It_can_include_templates_over_three_levels_with_external_includes()
        {
            var baseTemplate = new Template("Base");
            baseTemplate.Load(new StringReader("Base{{>BaseContent}}"));

            var masterTemplate = new Template("Master");
            masterTemplate.Load(new StringReader("{{<BaseContent}}Master{{>MasterContent}}{{/BaseContent}}{{>Base}}"));

            var templates = new Dictionary<string, Template>();
            templates.Add("Base", baseTemplate);
            templates.Add("Master", masterTemplate);

            TemplateLocator locateTemplate =
                name =>
                {
                    Template ret;
                    templates.TryGetValue(name, out ret);
                    if (ret == null) throw new KeyNotFoundException(string.Format("The view '{0}' could not be found.", name));
                    return ret;
                };

            var result = Render.StringToString("{{<MasterContent}}Hello{{/MasterContent}}{{>Master}}", null, locateTemplate);

            Assert.AreEqual("BaseMasterHello", result);
        }

        public virtual Template GetMessageTemplate(bool verbose)
        {
            Template messageST = new Template(GetErrorType().msg);
            messageST.impl.Name = errorType.Name;

            messageST.Add("verbose", verbose);
            object[] args = GetArgs();
            for (int i = 0; i < args.Length; i++)
            {
                string attr = "arg";
                if (i > 0)
                    attr += i + 1;
                messageST.Add(attr, args[i]);
            }
            if (args.Length < 2)
                messageST.Add("arg2", null); // some messages ref arg2

            Exception cause = GetCause();
            if (cause != null)
            {
                messageST.Add("exception", cause);
                messageST.Add("stackTrace", cause.StackTrace);
            }
            else
            {
                messageST.Add("exception", null); // avoid ST error msg
                messageST.Add("stackTrace", null);
            }

            return messageST;
        }

		public virtual IUimlElement Resolve(Template t, IUimlElement placeholder)
		{
			// add all children of the template's top element to placeholder's children 
			Console.Write("Trying to unite element '{0}' with template '{1}'... ", ((UimlAttributes) placeholder).Identifier, t.Identifier);

			try
			{
				// check if types are compatible
				if (t.Top.GetType().Equals(placeholder.GetType()))
				{
					// TODO: check for children with the same identifier, and resolve name conflicts!
					// add elements from template's top element
					placeholder.Children.AddRange(t.Top.Children);	
					Console.WriteLine("OK!");
				}
				else
					Console.WriteLine("Failed! -> incompatible types, no action taken");
			}
			catch (Exception e)
			{
				Console.WriteLine("Failed!");
			}

			return placeholder; // always return placeholder, whether it's modified or not
		}

 public void TestComplicatedExpression()
 {
     var templateContent = "${(8+2)*(5+5) - ((2+8)/2)}";
     var template = new Template(templateContent);
     var render = template.Render();
     Assert.AreEqual("95", render);
 }

 public void TestUnknownVariablesAreIgnored()
 {
     Template template = new Template("Hello, ${name}");
     template.Set("unknown", "Hi");
     template.Set("name", "Tom");
     Assert.AreEqual("Hello, Tom", template.Evaluate());
 }

        public bool AddTemplate(Template template) {
            Debug.Assert(template.ImportPrecedence == 0);

            template.ImportPrecedence = this.importPrecedence;
            template.OrderNumber      = this.orderNumber++;

            compiler.AllTemplates.Add(template);

            if (template.Name != null) {
                Template old;
                if (!compiler.NamedTemplates.TryGetValue(template.Name, out old)) {
                    compiler.NamedTemplates[template.Name] = template;
                } else {
                    Debug.Assert(template.ImportPrecedence <= old.ImportPrecedence, "Global objects are processed in order of decreasing import precedence");
                    if (old.ImportPrecedence == template.ImportPrecedence) {
                        return false;
                    }
                }
            }

            if (template.Match != null) {
                Templates.Add(template);
            }
            return true;
        }

        public static void GenerateMain(string entryType, string entryNamespace, bool inputArgs)
        {
            StreamWriter writer = new StreamWriter(FileWritterManager.WorkingPath + "main.cpp");

            string txt;
            Template template;

            string altTools = Environment.GetEnvironmentVariable("ALTERNATIVE_TOOLS_PATH");

            if(altTools == null)
                altTools = Path.Combine(Environment.CurrentDirectory, (@"..\..\..\Tools").Replace('\\','/'));

            StreamReader sr = new StreamReader((altTools + @"\Templates\Code\main.stg").Replace('\\', '/'));
            txt = sr.ReadToEnd();
            template = new Template(txt);

            StreamReader fs = new StreamReader(Path.Combine(altTools, "Text/notice"));
            string notice = fs.ReadToEnd();

            template.Add("NOTICE", notice);
            template.Add("ENTRY_TYPE", entryType);
            template.Add("ENTRY_NAMESPACE_NEEDED", !String.IsNullOrEmpty(entryNamespace));
            template.Add("ENTRY_NAMESPACE", entryNamespace);
            template.Add("INPUT_ARGS", inputArgs);

            string output = template.Render();

            writer.Write(output);
            writer.Flush();
            writer.Close();

            FileWritterManager.AddSourceFile("main.cpp");
        }

        public List<IResource> GetResources(int folderId)
        {
            IResource template1 = new Template { Name = "Template1", Description = "Template1 description" };

            // Just return a List of simple templates for now
            return new List<IResource> { template1 };
        }

 public static void RunTest(string template, string expected, string errMsg)
 {
     string actual = new Template(template).Render(globals);
     actual = actual.Replace("{", "{{").Replace("}", "}}");
     Assert.AreEqual(expected, actual, "{1} - {0}template: {2}{0}actual: {3}{0}expected: {4}",
         Environment.NewLine, errMsg, template, actual, expected);
 }

        public void It_handles_nested_sections_with_the_same_name()
        {
            var parser = new Parser();
            var template = new Template();

            parser.Parse(template,
                         new Part[]
                             {
                                 new LiteralText("before foo 1"),
                                 new Block("foo"),
                                 new LiteralText("before foo 2"),
                                 new Block("foo"),
                                 new LiteralText("inside foo 2"),
                                 new EndSection("foo"),
                                 new LiteralText("after foo 2"),
                                 new EndSection("foo"),
                                 new LiteralText("after foo 1")
                             });

            template.Parts.IsEqualTo(new LiteralText("before foo 1"),
                                     new Block("foo",
                                               new LiteralText("before foo 2"),
                                               new Block("foo",
                                                         new LiteralText("inside foo 2"),
                                                         new EndSection("foo")),
                                               new LiteralText("after foo 2"),
                                               new EndSection("foo")),
                                     new LiteralText("after foo 1"));
        }

        public void Init(Template template, App app, ModuleInfo hostingModule, IDataSource dataSource, InstancePurposes instancePurposes, SxcInstance sexy)
        {
            var templatePath = VirtualPathUtility.Combine(Internal.TemplateManager.GetTemplatePathRoot(template.Location, app) + "/", template.Path);

            // Throw Exception if Template does not exist
            if (!File.Exists(HostingEnvironment.MapPath(templatePath)))
                // todo: rendering exception
                throw new SexyContentException("The template file '" + templatePath + "' does not exist.");

            Template = template;
            TemplatePath = templatePath;
            App = app;
            ModuleInfo = hostingModule;
            DataSource = dataSource;
            InstancePurposes = instancePurposes;
            Sexy = sexy;

            // check common errors
            CheckExpectedTemplateErrors();

            // check access permissions - before initializing or running data-code in the template
            CheckTemplatePermissions(sexy.AppPortalSettings);

            // Run engine-internal init stuff
            Init();

            // call engine internal feature to optionally change what data is actually used or prepared for search...
            CustomizeData();

            // check if rendering is possible, or throw exceptions...
            CheckExpectedNoRenderConditions();

            if(PreRenderStatus == RenderStatusType.Unknown)
                PreRenderStatus = RenderStatusType.Ok;
        }

        private static void RunMustacheSpecs(MustacheSpec.MustacheTest test)
        {
            TemplateLocator testDataTemplateLocator = name =>
            {
                if (test.Partials != null && test.Partials[name] != null)
                {
                    var template = new Template();
                    template.Load(new StringReader(test.Partials[name].ToString()));
                    return template;
                };

                return null;
            };

            var rendered = Render.StringToString(test.Template, test.Example, testDataTemplateLocator);
            Assert.AreEqual(test.Expected, rendered, "JSON object rendering failed for " + test.Description);

            rendered = Render.StringToString(test.Template, test.StronglyTypedExample, testDataTemplateLocator);
            Assert.AreEqual(test.Expected, rendered, "Strongly typed rendering failed for " + test.Description);

            var templ = new Template();
            templ.Load(new StringReader(test.Template));

            if (!test.Name.ToLower().Contains("context miss") &&
                !test.Name.ToLower().Contains("broken chain") &&
                !(test.SpecName == "inverted" && (test.Name == "List" || test.Name == "Context")))
            {
                try
                {
                    var compiledTemplate = templ.Compile(
                    test.StronglyTypedExample != null ? test.StronglyTypedExample.GetType() : typeof(object),
                    testDataTemplateLocator);
                    rendered = compiledTemplate(test.StronglyTypedExample);
                    Assert.AreEqual(test.Expected, rendered, "Compiled Template rendering failed for " + test.Description);
                }
                catch (Nustache.Core.NustacheException ex)
                {
                    if (ex.Message.StartsWith("Unsupported:"))
                    {
                        Assert.Inconclusive(ex.Message);
                    }
                }
            }
            else
            {
                bool gotException = false;
                try
                {
                    var compiledTemplate = templ.Compile(
                        test.StronglyTypedExample != null ? test.StronglyTypedExample.GetType() : typeof(object),
                        testDataTemplateLocator);
                }
                catch (Compilation.CompilationException)
                {
                    gotException = true;
                }

                Assert.IsTrue(gotException, "Expected test to throw a compilation exception for an invalid template");
            }
        }