public override void Render(Context context, TextWriter result)
        {
            var template = context[this._templateName].ToNullOrString();
            if (template == null)
            {
                template = this._templateName;
            }

            context.Registers["layout"] = template;
        }

        public override string PrepareTemplateContents(string content, Context context, string templateName)
        {
            var templatePage = new TemplatePage(content);

            templatePage.Body = templatePage.Body.Replace("{{ content }}",
                string.Format("{{% block {0}_content -%}}{{% endblock -%}}", templateName));

            WrapWithTemplate(templatePage);

            return templatePage.Body;
        }

        public override void Render(Context context, TextWriter result)
        {
            var mutablePagedList = context[_collectionName] as IMutablePagedList;
            var collection = context[_collectionName] as ICollection;
            var pagedList = context[_collectionName] as IPagedList;
            Uri requestUrl;
            Uri.TryCreate(context["request_url"] as string, UriKind.RelativeOrAbsolute, out requestUrl);
            var pageNumber = (int)context["current_page"];
 
            if (mutablePagedList != null)
            {
                mutablePagedList.Slice(pageNumber, _pageSize > 0 ? _pageSize : 20);
                pagedList = mutablePagedList;
            }
            else if (collection != null)
            {
                pagedList = new PagedList<Drop>(collection.OfType<Drop>().AsQueryable(), pageNumber, _pageSize);                
                //TODO: Need find way to replace ICollection instance in liquid context to paged instance
                //var hash = context.Environments.FirstOrDefault(s => s.ContainsKey(_collectionName));
                //hash[_collectionName] = pagedList;
            }

            if (pagedList != null)
            {
                var paginate = new Paginate(pagedList);
                context["paginate"] = paginate;

                for (int i = 1; i <= pagedList.PageCount; i++)
                {
                    paginate.Parts.Add(new Part { IsLink = i != pagedList.PageNumber, Title = i.ToString(), Url = requestUrl != null ? requestUrl.SetQueryParameter("page", i.ToString()).ToString() : i.ToString() });
                }
                RenderAll(NodeList, context, result);
            }
        }

 public override void CompileTemplate(string templatePath)
 {
     var name = GetTemplateName(templatePath);
     var context = new Context();
     var contents = Template.FileSystem.ReadTemplateFile(context, name);
     templatesByName[name] = Template.Parse(contents);
 }

        public void Render(Context context, TextWriter result)
        {
            object output = RenderInternal(context);

            if (output is ILiquidizable)
                output = null;

            if (output != null)
            {
                var transformer = Template.GetValueTypeTransformer(output.GetType());
                
                if(transformer != null)
                output = transformer(output);

                //treating Strings as IEnumerable, and was joining Chars in loop
                string outputString = output as string;

                if (outputString != null) {}
                else if (output is IEnumerable)
#if NET35
                    outputString = string.Join(string.Empty, ((IEnumerable)output).Cast<object>().Select(o => o.ToString()).ToArray());
#else
                    outputString = string.Join(string.Empty, ((IEnumerable)output).Cast<object>());
#endif
                else if (output is bool)
                    outputString = output.ToString().ToLower();
                else
                    outputString = output.ToString();
                result.Write(outputString);
            }

 public static Strainer Create(Context context)
 {
     Strainer strainer = new Strainer(context);
     foreach (var keyValue in Filters)
         strainer.Extend(keyValue.Value);
     return strainer;
 }

        public void Render(Context context, TextWriter result)
        {
            object output = RenderInternal(context);

            if (output is ILiquidizable)
                output = null;

            if (output != null)
            {
                // see if this context has a ValueTypeTranformer for the type
                var transformer = context.GetValueTypeTransformer(output.GetType());
                if (transformer == null)
                {
                    // if the context doesn't have a ValueTypeTranformer for the type, get the global one (if there is one)
                    transformer = Template.GetValueTypeTransformer(output.GetType());
                }

                if(transformer != null)
                    output = transformer(output);

                string outputString;
                if (output is IEnumerable)
            #if NET35
                    outputString = string.Join(string.Empty, ((IEnumerable)output).Cast<object>().Select(o => o.ToString()).ToArray());
            #else
                    outputString = string.Join(string.Empty, ((IEnumerable)output).Cast<object>());
            #endif
                else if (output is bool)
                    outputString = output.ToString().ToLower();
                else
                    outputString = output.ToString();
                result.Write(outputString);
            }

        public static string Display(Context context, dynamic input)
        {
            if (input == null || !(input is StaticShape)) return string.Empty;

            StaticShape shape = input;

            var wc = context.GetWorkContext();

            // Checking if the shape is displayed multiple times. If yes it can be legitimate (although rare) but
            // can also indicate unwanted recursion, so capping it.
            if (shape.Shape.DisplayedCount == null) shape.Shape.DisplayedCount = 0;

            if (shape.Shape.DisplayedCount >= Constants.MaxAllowedShapeDisplayCount)
            {
                wc.LogSecurityNotificationWithContext(typeof(DisplayFilter), "Too many displays of the same shape prevented.");

                return string.Empty;
            }

            shape.Shape.DisplayedCount++;

            if (!context.ShapeIsWithinAllowedRecursionDepth(shape.Metadata.Type))
            {
                wc.LogSecurityNotificationWithContext(typeof(DisplayFilter), "Too many recursive shape displays prevented.");

                return string.Empty;
            }

            context.AddCurrentShapeAsParentToShape((IShape)shape.Shape);

            return wc.Resolve<IShapeDisplay>().Display(shape.Shape);
        }

        public override void Render(Context context, TextWriter result)
        {
            var formName = (context[_formName] ?? _formName).ToString();

            string actionUrl;
            if (_formsMap.TryGetValue(formName, out actionUrl))
            {
                var themeEngine = (ShopifyLiquidThemeEngine)Template.FileSystem;
                var qs = HttpUtility.ParseQueryString(themeEngine.WorkContext.RequestUrl.Query);
                var returnUrl = qs["ReturnUrl"];
                var actionAbsoluteUrl = themeEngine.UrlBuilder.ToAppAbsolute(actionUrl, themeEngine.WorkContext.CurrentStore, themeEngine.WorkContext.CurrentLanguage);

                if (!string.IsNullOrEmpty(returnUrl))
                {
                    actionAbsoluteUrl += string.Concat("?ReturnUrl=", HttpUtility.UrlEncode(returnUrl));
                }

                result.WriteLine("<form accept-charset=\"UTF-8\" action=\"{0}\" method=\"post\" id=\"{1}\">",
                    HttpUtility.HtmlAttributeEncode(actionAbsoluteUrl),
                    HttpUtility.HtmlAttributeEncode(formName));

                RenderAll(NodeList, context, result);

                result.WriteLine("</form>");
            }
            else
            {
                throw new SyntaxException(string.Concat("Unknow form type ", _formName));
            }

        }

        protected RequireSettings IncludeResource(string resourceType, string resourcePath, Context context)
        {
            var workContext = context.GetWorkContext();
            var resourceManager = workContext.Resolve<IResourceManager>();
            var pathResolver = workContext.Resolve<ITemplateItemProvidedPathResolver>();

            var renderingContext = context.GetTemplateRenderingContext();
            // If a template file is being rendered then resources paths can be used as usual from themes; if a
            // template item is rendered then relative virtual paths should be handled the same way (those reference
            // flat files).
            if (renderingContext.TemplateType == Models.TemplateType.TemplateFile ||
                (resourcePath.StartsWith("~") && pathResolver.IsRealVirtualPath(resourcePath)))
            {
                var resourceRegister = new ResourceRegister(
                    new DummyWebPage { VirtualPath = renderingContext.TemplatePath },
                    resourceManager,
                    resourceType);
                return resourceRegister.Include(resourcePath);
            }
            else
            {
                if (!resourcePath.StartsWith("//") &&
                    !resourcePath.StartsWith("http://", StringComparison.OrdinalIgnoreCase) &&
                    !resourcePath.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
                {
                    resourcePath = pathResolver.GenerateUrlFromPath(resourcePath);
                }

                return resourceManager.Include(resourceType, resourcePath, resourcePath);
            }
        }

        public override void Render(Context context, TextWriter result)
        {
            if (string.IsNullOrEmpty(_classNameParameter)) return;

            dynamic shape = context["Model"];
            shape.Classes.Add(_classNameParameter.EvaluateAsStringProducingParameter(context));
        }

		/// <summary>
		/// 描画内容
		/// </summary>
		/// <param name="context"></param>
		/// <param name="result"></param>
		public override void Render(Context context, TextWriter result) {
			// 获取所在区域，没有区域时抛例外
			if (context[Area.CurrentAreaIdKey] == null) {
				throw new FormatException("widget must use inside area");
			}
			// 获取模块名称和参数
			var markup = this.Markup.Trim();
			string widgetPath = null;
			string widgetArgs = null;
			var index = markup.IndexOf(' ');
			if (index > 0) {
				widgetPath = markup.Substring(0, index);
				widgetArgs = markup.Substring(index + 1);
			} else {
				widgetPath = markup;
			}
			// 添加div的开头
			result.Write($"<div class='diy_widget' path='{widgetPath}' args='{widgetArgs}' >");
			// 描画模块的内容
			var scope = widgetArgs == null ? new Hash() : Hash.FromDictionary(
				JsonConvert.DeserializeObject<IDictionary<string, object>>(widgetArgs));
			context.Stack(scope, () => {
				var includeTag = new Include();
				var htmlPath = widgetPath + DiyWidgetInfo.HtmlExtension;
				includeTag.Initialize("include", htmlPath, null);
				includeTag.Render(context, result);
			});
			// 添加div的末尾
			result.Write("</div>");
		}

        public static string EvaluateAsStringProducingParameter(this string parameterValue, Context context)
        {
            var evaluatedParameter = parameterValue.EvaluateAsParameter(context);

            if (evaluatedParameter == null) return null;
            if (evaluatedParameter is string) return (string)evaluatedParameter;
            return evaluatedParameter.ToString();
        }

 /// <summary>
 /// Primarily intended for testing.
 /// </summary>
 /// <param name="context"></param>
 /// <returns></returns>
 internal string Render(Context context)
 {
     using (TextWriter result = new StringWriter())
     {
         Render(context, result);
         return result.ToString();
     }
 }

 public override void Render(Context context, TextWriter result)
 {
     // It's easier to fake every context and create a HtmlHelper to use the ClassForPage() extension. Note that
     // we also need to encode the output (and this is done in the ClassForPage() extension method)!
     context.WriteHtmlHelperOutputToResult(
         html => html.ClassForPage(GetEvaluatedParameters(context)),
         result);
 }

 /// <summary>
 /// Primarily intended for testing.
 /// </summary>
 /// <param name="context"></param>
 /// <returns></returns>
 internal string Render(Context context)
 {
     using (MemoryStreamWriter result = new MemoryStreamWriter())
     {
         Render(context, result);
         return result.ToString();
     }
 }

 public string ReadTemplateFile(Context context, string templateName)
 {
     var include = Path.Combine(this.Root, "snippets", templateName);
     if (File.Exists(include))
     {
         return File.ReadAllText(include);
     }
     return string.Empty;
 }

		public string ReadTemplateFile(Context context, string templateName)
		{
			string includePath = Path.Combine(root, templateName);
			
			if (File.Exists(includePath))
				return File.ReadAllText(includePath);
			
			return string.Empty;
		}

        public override void Render(Context context, TextWriter result)
        {
            if (string.IsNullOrEmpty(_titleParameter)) return;

            context
                .GetWorkContext()
                .Resolve<IPageTitleBuilder>()
                .AddTitleParts(_titleParameter.EvaluateAsStringProducingParameter(context));
        }

    public IHttpActionResult Get(int seriesId)
    {
        var rockContext = new RockContext();

        var contentItemService = new ContentChannelService(rockContext);
        var d = new DotLiquid.Context();
        ContentChannel contentItem = null;

        var attrService = new AttributeService(rockContext);

        var dailyItems = new List<MessageArchiveItem>();

        var ids = rockContext.Database.SqlQuery<int>("exec GetMessageArchivesBySeriesId @seriesId", new SqlParameter("seriesId", seriesId)).ToList();

        contentItem = contentItemService.Get(11);

        var items = contentItem.Items.Where(a => ids.Contains(a.Id)).ToList();

        foreach (var item in items)
        {

            item.LoadAttributes(rockContext);

            var link = GetVimeoLink(item.GetAttributeValue("VideoId"));

            var newItem = new MessageArchiveItem();

            newItem.Id = item.Id;

            //   newItem.Content = item.Content;

            newItem.Content = DotLiquid.StandardFilters.StripHtml(item.Content).Replace("\n\n", "\r\n\r\n");

            newItem.Date = DateTime.Parse(item.GetAttributeValue("Date")).ToShortDateString();
            newItem.Speaker = item.GetAttributeValue("Speaker");
            newItem.SpeakerTitle = item.GetAttributeValue("SpeakerTitle");
            newItem.Title = item.Title;
            newItem.VimeoLink = link;

            var notesAttr = item.Attributes["MessageNotes"];

            var binaryFile = new BinaryFileService(new RockContext()).Get(notesAttr.Id);

            if (binaryFile != null)
                newItem.Notes = binaryFile.Url;

            var talkAttr = item.Attributes["TalkItOver"];
            binaryFile = new BinaryFileService(new RockContext()).Get(talkAttr.Id);
            if (binaryFile != null)
                newItem.TalkItOver = binaryFile.Url;

            dailyItems.Add(newItem);
        }

        return Ok(dailyItems.AsQueryable());
    }