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

            context.Registers["layout"] = template;
        }
예제 #2
1
        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;
        }
예제 #3
0
파일: Variable.cs 프로젝트: Elph/dotliquid
        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);
            }
예제 #4
0
 public static Strainer Create(Context context)
 {
     Strainer strainer = new Strainer(context);
     foreach (var keyValue in Filters)
         strainer.Extend(keyValue.Value);
     return strainer;
 }
        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));
        }
예제 #7
0
 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);
 }
예제 #8
0
파일: Widget.cs 프로젝트: daywrite/ZKWeb
		/// <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 override void Render(DotLiquid.Context context, TextWriter result)
        {
            NavigationMenuItemDrop navigationMenuItemDrop = (NavigationMenuItemDrop)null;

            if (!this.contextProperty.IsBlank())
            {
                object obj = context[this.contextProperty];
                if (obj is int)
                {
                    this.variantKeyFromMarkup = (int)obj;
                }
                else if (obj is NavigationMenuItemDrop)
                {
                    navigationMenuItemDrop = obj as NavigationMenuItemDrop;
                }
            }
            if (navigationMenuItemDrop == null)
            {
                AbstractPage page = DependencyLocator.Current.GetInstance <IContentHelper>().GetPageByVariantKey(this.variantKeyFromMarkup, false).Page;
                navigationMenuItemDrop = !(page is ICatalogNavigationPage) ? this.CreateContentNavigationLink(DependencyLocator.Current.GetInstance <IContentHelper>(), page, this.viewNameFromMarkup, 0) : this.CreateCatalogNavigationLink(((ICatalogNavigationPage)page).CategoryNavRoot, this.viewNameFromMarkup, 0);
            }
            string str = DependencyLocator.Current.GetInstance <IContentItemTemplateRenderer>().RenderNavigationMenu(navigationMenuItemDrop);

            result.Write(str);
        }
예제 #10
0
        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));
            }

        }
예제 #11
0
        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);
            }
        }
예제 #12
0
파일: Variable.cs 프로젝트: NewSpring/Rock
        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);
            }
예제 #13
0
        /// <summary>
        /// Gets the current person.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <returns></returns>
        private static Person GetCurrentPerson(Context context)
        {
            Person currentPerson = null;

            // First check for a person override value included in lava context
            if (context.Scopes != null)
            {
                foreach (var scopeHash in context.Scopes)
                {
                    if (scopeHash.ContainsKey("CurrentPerson"))
                    {
                        currentPerson = scopeHash["CurrentPerson"] as Person;
                    }
                }
            }

            if (currentPerson == null)
            {
                var httpContext = System.Web.HttpContext.Current;
                if (httpContext != null && httpContext.Items.Contains("CurrentPerson"))
                {
                    currentPerson = httpContext.Items["CurrentPerson"] as Person;
                }
            }

            return(currentPerson);
        }
예제 #14
0
        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);
        }
예제 #15
0
파일: Tag.cs 프로젝트: devSolo/dotliquid
 /// <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();
     }
 }
예제 #16
0
 /// <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();
     }
 }
예제 #17
0
 /// <summary>
 /// Properties the specified context.
 /// </summary>
 /// <param name="context">The context.</param>
 /// <param name="input">The input.</param>
 /// <param name="propertyKey">The property key.</param>
 /// <param name="qualifier">The qualifier.</param>
 /// <returns></returns>
 public static object Property(DotLiquid.Context context, object input, string propertyKey, string qualifier = "")
 {
     if (input != null)
     {
         return(input.GetPropertyValue(propertyKey));
     }
     return(string.Empty);
 }
        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();
        }
 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);
 }
예제 #20
0
        public override void Render(Context context, TextWriter result)
        {
            if (string.IsNullOrEmpty(_titleParameter)) return;

            context
                .GetWorkContext()
                .Resolve<IPageTitleBuilder>()
                .AddTitleParts(_titleParameter.EvaluateAsStringProducingParameter(context));
        }
 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;
 }
예제 #22
0
		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 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());
    }
예제 #24
0
            public string ReadTemplateFile(DotLiquid.Context context, string templateName)
            {
                var include = Path.Combine(Root, "Includes", templateName);

                if (File.Exists(include))
                {
                    return(File.ReadAllText(include));
                }
                return(string.Empty);
            }
예제 #25
0
		/// <summary>
		/// 添加html到变量中,不重复添加
		/// </summary>
		public override void Render(Context context, TextWriter result) {
			var css = context[Key] as string ?? "";
			var html = string.Format(
				"<link href='{0}' rel='stylesheet' type='text/css' />\r\n",
				HttpUtility.HtmlAttributeEncode(Markup.Trim()));
			if (!css.Contains(html)) {
				css += html;
				context[Key] = css;
			}
		}
예제 #26
0
        public override void Render(Context context, TextWriter result)
        {
            if (string.IsNullOrEmpty(_shapeType)) return;

            var wc = HttpContext.Current.GetWorkContext();

            if (wc == null) return;

            result.Write(wc.Resolve<IShapeDisplay>().Display(wc.Resolve<IShapeFactory>().Create(_shapeType, Arguments.From(_arguments))));
        }
예제 #27
0
		/// <summary>
		/// 添加html到变量中,不重复添加
		/// </summary>
		public override void Render(Context context, TextWriter result) {
			var js = context[Key] as string ?? "";
			var html = string.Format(
				"<script src='{0}' type='text/javascript'></script>\r\n",
				HttpUtility.HtmlAttributeEncode(Markup.Trim()));
			if (!js.Contains(html)) {
				js += html;
				context[Key] = js;
			}
		}
예제 #28
0
        public override void Render(Context context, TextWriter result)
        {
            var template = (context[this._templateName] ?? String.Empty).ToString();
            if (String.IsNullOrEmpty(template))
            {
                template = this._templateName;
            }

            context.Registers["layout"] = template;
        }
예제 #29
0
        public static string Display(Context context, dynamic input)
        {
            if (input == null || !(input is StaticShape)) return string.Empty;

            StaticShape shape = input;
            var wc = HttpContext.Current.GetWorkContext();

            if (wc == null) return string.Empty;

            return wc.Resolve<IShapeDisplay>().Display(shape.Shape);
        }
        public string ReadTemplateFile(Context context, string templateName)
        {
            var templatePath = (string)context[templateName];

            var resolver = context.Registers[Guid] as IResourceResolver;

            var resource = resolver.GetResource("~/" + templatePath + ".liquid");
            using (var stream = resource.Open())
            using (var reader = new StreamReader(stream))
                return reader.ReadToEnd();
        }
예제 #31
0
        public override void Render(Context context, System.IO.TextWriter result)
        {
            result.Write("<blockquote>");

            result.Write("<p>");
            base.Render(context, result);
            result.Write("</p>");

            result.Write(this.htmlAuthor);

            result.Write("</blockquote>");
        }
예제 #32
0
	    public override void Render(Context context, TextWriter result)
	    {
	        try
	        {
	            base.Render(context, result);
	        }
	        catch (BreakInterrupt)
	        {
	        }
	        catch (ContinueInterrupt)
	        {
	        }
	    }
예제 #33
0
 /// <summary>
 /// Gets the rock context.
 /// </summary>
 /// <param name="context">The context.</param>
 /// <returns></returns>
 private static RockContext GetRockContext(DotLiquid.Context context)
 {
     if (context.Registers.ContainsKey("rock_context"))
     {
         return(context.Registers["rock_context"] as RockContext);
     }
     else
     {
         var rockContext = new RockContext();
         context.Registers.Add("rock_context", rockContext);
         return(rockContext);
     }
 }
예제 #34
0
        public override void Render(Context context, TextWriter result)
        {
            var template = Templates.GetCached(_templatePath);

            var parameters = new Hash();

            foreach (var assignment in _assignmentMap)
            {
                parameters.Add(assignment.Key, context[assignment.Value]);
            }

            result.Write(template.Render(parameters));
        }
예제 #35
0
 public string ReadTemplateFile(Context context, string templateName)
 {
     switch (templateName)
     {
         case "MasterTemplate":
             return CustomTemplates.MasterTemplate;
         case "PartialTemplate":
             return CustomTemplates.PartialTemplate;
         case "ChildTemplate":
             return CustomTemplates.ChildTemplate;
         default:
             throw new Exception("Template Not Found");
     }
 }
예제 #36
0
 public string ReadTemplateFile(DL.Context context, string templateName)
 {
     lock (Lock)
     {
         if (string.IsNullOrEmpty(templateName))
         {
             throw new ArgumentNullException(nameof(templateName), "Template name must be set.");
         }
         var len = templateName.Length;
         templateName = templateName[0] == '"' ? templateName.Substring(1) : templateName;
         templateName = templateName[len - 1] == '"' ? templateName.Substring(0, len - 1) : templateName;
         return(_includes.ContainsKey(templateName) ? _includes[templateName] : "The key not found");
     }
 }
예제 #37
0
파일: Tracer.cs 프로젝트: StenPetrov/Wham
        public static ITracer GetTracer(this DotLiquid.Context context, Guid?sessionId = null)
        {
            sessionId = sessionId ?? Guid.NewGuid();

            // get the tracer from context or create a new one via callback or use a default console tracer
            ITracer tracer = (context [TracerContextKey] as ITracer)
                             ?? Tracer.GetCreateTracer?.Invoke(sessionId.Value)
                             ?? new ConsoleTracer(sessionId.Value);

            if (context [TracerContextKey] != tracer)
            {
                context [TracerContextKey_SessionId] = sessionId.ToString();
                context [TracerContextKey]           = tracer;
            }

            return(tracer);
        }
        public override void Render(DotLiquid.Context context, TextWriter result)
        {
            var pageContext       = (PageContext.Current as PageContext);
            var contentController = pageContext.GetType().GetProperty("Controller", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).GetValue(pageContext) as Controller;


            ViewContext viewContext = new ViewContext(contentController.ControllerContext,
                                                      (IView) new FakeView(), contentController.ViewData, contentController.TempData, TextWriter.Null);
            ViewRenderer   viewRenderer     = new ViewRenderer((ControllerContext)viewContext);
            HtmlHelper     htmlHelper       = new HtmlHelper(viewContext, (IViewDataContainer) new ViewPage());
            IContentHelper contentHelper    = DependencyLocator.Current.GetInstance <IContentHelper>();
            int            parentVariantKey = contentHelper.GetPage("Home", false).Page.VariantKey.Value;

            BrasselerCatalogNavigationPage catalogNavItem = (BrasselerCatalogNavigationPage)contentHelper.GetChildPages <AbstractPage>(contentHelper.GetPage <HomePage>()
                                                                                                                                       .Page.ContentKey)
                                                            .Where(o => !o.ExcludeFromNavigation && o.ContentKey.Equals(contentHelper.GetPage <BrasselerCatalogNavigationPage>().Page.ContentKey))
                                                            .FirstOrDefault();


            MyAccountPage myAccountNavItem = (MyAccountPage)contentHelper.GetChildPages <AbstractPage>(contentHelper.GetPage <HomePage>().Page.ContentKey).Where(o => !o.ExcludeFromNavigation && o.ContentKey.Equals(contentHelper.GetPage <MyAccountPage>().Page.ContentKey)).FirstOrDefault();

            result.Write("<ul>");

            if (catalogNavItem != null)
            {
                string catalogThemedPartialPath = htmlHelper.GetThemedPartialPath(string.Format("{0}{1}.cshtml", (object)catalogNavItem.NavigationViewDirectory, (object)this.ViewName));
                result.Write(viewRenderer.RenderPartialView(catalogThemedPartialPath, (object)catalogNavItem));
            }

            if (myAccountNavItem != null)
            {
                if (!((SiteContext.Current.UserProfileDto != null) && (SiteContext.Current.BillTo.CustomerNumber.Length >= 1 && (SiteContext.Current.BillTo.CustomerNumber.Substring(1) == customSetting.Brasseler_GuestCustomerNumber))))
                {
                    string myAccountThemedPartialPath = htmlHelper.GetThemedPartialPath(string.Format("{0}{1}.cshtml", (object)myAccountNavItem.NavigationViewDirectory, (object)this.ViewName));
                    result.Write(viewRenderer.RenderPartialView(myAccountThemedPartialPath, (object)myAccountNavItem));
                }
            }

            if (SiteContext.Current.UserProfileDto != null)
            {
                result.Write("<li style='float:right'> <a class='cms-linklist-linkitem' href='/QuickOrder'>[% translate 'Quick Order' %]</a></li>");
            }

            result.Write("</ul>");
        }
        /// <summary>
        /// Loads a Group record from the database from it's Identifier.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="input">The input.</param>
        /// <returns></returns>
        public static Rock.Model.Group GroupById(DotLiquid.Context context, object input)
        {
            if (input == null)
            {
                return(null);
            }

            int groupId = -1;

            if (!Int32.TryParse(input.ToString(), out groupId))
            {
                return(null);
            }

            var rockContext = new RockContext();

            return(new GroupService(rockContext).Get(groupId));
        }
        /// <summary>
        /// Loads a Group Member record from the database from it's GUID.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="input">The input.</param>
        /// <returns></returns>
        public static Rock.Model.GroupMember GroupMemberByGuid(DotLiquid.Context context, object input)
        {
            if (input == null)
            {
                return(null);
            }

            Guid?groupMemberGuid = input.ToString().AsGuidOrNull();

            if (groupMemberGuid.HasValue)
            {
                var rockContext = new RockContext();

                return(new GroupMemberService(rockContext).Get(groupMemberGuid.Value));
            }
            else
            {
                return(null);
            }
        }
예제 #41
0
 public override void Render(DL.Context _context, System.IO.TextWriter _result)
 {
     if (null != m_Template)
     {
         try
         {
             var _renderParams = DL.RenderParameters.FromContext(_context);
             _result.Write(m_Template.Render(_renderParams));
         }
         catch (Exception _err)
         {
             Log.E(_err);
             _result.Write("(error)");
         }
     }
     else if (null != m_Content)
     {
         _result.Write(m_Content);
     }
     else
     {
         _result.Write("(null)");
     }
 }
예제 #42
0
        /// <summary>
        /// DotLiquid Attribute Filter
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="input">The input.</param>
        /// <param name="attributeKey">The attribute key.</param>
        /// <param name="qualifier">The qualifier.</param>
        /// <returns></returns>
        public static object Attribute(DotLiquid.Context context, object input, string attributeKey, string qualifier = "")
        {
            if (input == null || attributeKey == null)
            {
                return(string.Empty);
            }

            // Try to get RockContext from the dotLiquid context
            var rockContext = GetRockContext(context);

            AttributeCache attribute = null;
            string         rawValue  = string.Empty;

            // If Input is "Global" then look for a global attribute with key
            if (input.ToString().Equals("Global", StringComparison.OrdinalIgnoreCase))
            {
                var globalAttributeCache = Rock.Web.Cache.GlobalAttributesCache.Read(rockContext);
                attribute = globalAttributeCache.Attributes
                            .FirstOrDefault(a => a.Key.Equals(attributeKey, StringComparison.OrdinalIgnoreCase));
                if (attribute != null)
                {
                    // Get the value
                    string theValue = globalAttributeCache.GetValue(attributeKey);

                    // Global attributes may reference other global attributes, so try to resolve this value again
                    rawValue = theValue.ResolveMergeFields(new Dictionary <string, object>());
                }
            }

            // If input is an object that has attributes, find it's attribute value
            else if (input is IHasAttributes)
            {
                var item = (IHasAttributes)input;
                if (item.Attributes == null)
                {
                    item.LoadAttributes(rockContext);
                }

                if (item.Attributes.ContainsKey(attributeKey))
                {
                    attribute = item.Attributes[attributeKey];
                    rawValue  = item.AttributeValues[attributeKey].Value;
                }
            }

            // If valid attribute and value were found
            if (attribute != null && !string.IsNullOrWhiteSpace(rawValue))
            {
                Person currentPerson = null;

                // First check for a person override value included in lava context
                if (context.Scopes != null)
                {
                    foreach (var scopeHash in context.Scopes)
                    {
                        if (scopeHash.ContainsKey("CurrentPerson"))
                        {
                            currentPerson = scopeHash["CurrentPerson"] as Person;
                        }
                    }
                }

                if (currentPerson == null)
                {
                    var httpContext = System.Web.HttpContext.Current;
                    if (httpContext != null && httpContext.Items.Contains("CurrentPerson"))
                    {
                        currentPerson = httpContext.Items["CurrentPerson"] as Person;
                    }
                }

                if (attribute.IsAuthorized(Authorization.VIEW, currentPerson))
                {
                    // Check qualifier for 'Raw' if present, just return the raw unformatted value
                    if (qualifier.Equals("RawValue", StringComparison.OrdinalIgnoreCase))
                    {
                        return(rawValue);
                    }

                    // Check qualifier for 'Url' and if present and attribute's field type is a ILinkableFieldType, then return the formatted url value
                    var field = attribute.FieldType.Field;
                    if (qualifier.Equals("Url", StringComparison.OrdinalIgnoreCase) && field is Rock.Field.ILinkableFieldType)
                    {
                        return(((Rock.Field.ILinkableFieldType)field).UrlLink(rawValue, attribute.QualifierValues));
                    }

                    // If qualifier was specified, and the attribute field type is an IEntityFieldType, try to find a property on the entity
                    if (!string.IsNullOrWhiteSpace(qualifier) && field is Rock.Field.IEntityFieldType)
                    {
                        IEntity entity = ((Rock.Field.IEntityFieldType)field).GetEntity(rawValue);
                        if (entity != null)
                        {
                            if (qualifier.Equals("object", StringComparison.OrdinalIgnoreCase))
                            {
                                return(entity);
                            }
                            else
                            {
                                return(entity.GetPropertyValue(qualifier).ToStringSafe());
                            }
                        }
                    }

                    // Otherwise return the formatted value
                    return(field.FormatValue(null, rawValue, attribute.QualifierValues, false));
                }
            }

            return(string.Empty);
        }
예제 #43
0
        /// <summary>
        /// Addresses the specified context.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="input">The input.</param>
        /// <param name="addressType">Type of the address.</param>
        /// <param name="qualifier">The qualifier.</param>
        /// <returns></returns>
        public static string Address(DotLiquid.Context context, object input, string addressType, string qualifier = "")
        {
            if (input != null && input is Person)
            {
                var person = (Person)input;

                Guid familyGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
                var  location   = new GroupMemberService(GetRockContext(context))
                                  .Queryable("GroupLocations.Location")
                                  .Where(m =>
                                         m.PersonId == person.Id &&
                                         m.Group.GroupType.Guid == familyGuid)
                                  .SelectMany(m => m.Group.GroupLocations)
                                  .Where(gl =>
                                         gl.GroupLocationTypeValue.Value == addressType)
                                  .Select(gl => gl.Location)
                                  .FirstOrDefault();

                if (location != null)
                {
                    if (qualifier == "")
                    {
                        return(location.GetFullStreetAddress());
                    }
                    else
                    {
                        var matches = Regex.Matches(qualifier, @"\[\[([^\]]+)\]\]");
                        foreach (var match in matches)
                        {
                            string propertyKey = match.ToString().Replace("[", "");
                            propertyKey = propertyKey.ToString().Replace("]", "");
                            propertyKey = propertyKey.ToString().Replace(" ", "");

                            switch (propertyKey)
                            {
                            case "Street1":
                                qualifier = qualifier.Replace(match.ToString(), location.Street1);
                                break;

                            case "Street2":
                                qualifier = qualifier.Replace(match.ToString(), location.Street2);
                                break;

                            case "City":
                                qualifier = qualifier.Replace(match.ToString(), location.City);
                                break;

                            case "State":
                                qualifier = qualifier.Replace(match.ToString(), location.State);
                                break;

                            case "PostalCode":
                            case "Zip":
                                qualifier = qualifier.Replace(match.ToString(), location.PostalCode);
                                break;

                            case "Country":
                                qualifier = qualifier.Replace(match.ToString(), location.Country);
                                break;

                            case "GeoPoint":
                                if (location.GeoPoint != null)
                                {
                                    qualifier = qualifier.Replace(match.ToString(), string.Format("{0},{1}", location.GeoPoint.Latitude.ToString(), location.GeoPoint.Longitude.ToString()));
                                }
                                else
                                {
                                    qualifier = qualifier.Replace(match.ToString(), "");
                                }
                                break;

                            case "Latitude":
                                if (location.GeoPoint != null)
                                {
                                    qualifier = qualifier.Replace(match.ToString(), location.GeoPoint.Latitude.ToString());
                                }
                                else
                                {
                                    qualifier = qualifier.Replace(match.ToString(), "");
                                }
                                break;

                            case "Longitude":
                                if (location.GeoPoint != null)
                                {
                                    qualifier = qualifier.Replace(match.ToString(), location.GeoPoint.Longitude.ToString());
                                }
                                else
                                {
                                    qualifier = qualifier.Replace(match.ToString(), "");
                                }
                                break;

                            case "FormattedAddress":
                                qualifier = qualifier.Replace(match.ToString(), location.FormattedAddress);
                                break;

                            case "FormattedHtmlAddress":
                                qualifier = qualifier.Replace(match.ToString(), location.FormattedHtmlAddress);
                                break;

                            default:
                                qualifier = qualifier.Replace(match.ToString(), "");
                                break;
                            }
                        }

                        return(qualifier);
                    }
                }
            }

            return(string.Empty);
        }
예제 #44
0
        /// <summary>
        /// Parses the markup.
        /// </summary>
        /// <param name="markup">The markup.</param>
        /// <param name="context">The context.</param>
        /// <returns></returns>
        private Dictionary <string, string> ParseMarkup(string markup, Context context)
        {
            // first run lava across the inputted markup
            var internalMergeFields = new Dictionary <string, object>();

            // get variables defined in the lava source
            foreach (var scope in context.Scopes)
            {
                foreach (var item in scope)
                {
                    internalMergeFields.AddOrReplace(item.Key, item.Value);
                }
            }

            // get merge fields loaded by the block or container
            if (context.Environments.Count > 0)
            {
                foreach (var item in context.Environments[0])
                {
                    internalMergeFields.AddOrReplace(item.Key, item.Value);
                }
            }
            var resolvedMarkup = markup.ResolveMergeFields(internalMergeFields);

            var parms = new Dictionary <string, string>();

            parms.Add("iterator", string.Format("{0}Items", _entityName));
            parms.Add("securityenabled", "true");

            var markupItems = Regex.Matches(resolvedMarkup, @"(\S*?:'[^']+')")
                              .Cast <Match>()
                              .Select(m => m.Value)
                              .ToList();

            if (markupItems.Count == 0)
            {
                throw new Exception("No parameters were found in your command. The syntax for a parameter is parmName:'' (note that you must use single quotes).");
            }

            foreach (var item in markupItems)
            {
                var itemParts = item.ToString().Split(new char[] { ':' }, 2);
                if (itemParts.Length > 1)
                {
                    parms.AddOrReplace(itemParts[0].Trim().ToLower(), itemParts[1].Trim().Substring(1, itemParts[1].Length - 2));
                }
            }

            // override any dynamic parameters
            List <string> dynamicFilters = new List <string>(); // will be used to process dynamic filters

            if (parms.ContainsKey("dynamicparameters"))
            {
                var dynamicParms    = parms["dynamicparameters"];
                var dynamicParmList = dynamicParms.Split(',')
                                      .Select(x => x.Trim())
                                      .Where(x => !string.IsNullOrWhiteSpace(x))
                                      .ToList();

                foreach (var dynamicParm in dynamicParmList)
                {
                    if (HttpContext.Current.Request[dynamicParm] != null)
                    {
                        var dynamicParmValue = HttpContext.Current.Request[dynamicParm].ToString();

                        switch (dynamicParm)
                        {
                        case "id":
                        case "limit":
                        case "offset":
                        case "dataview":
                        case "expression":
                        case "sort":
                        case "iterator":
                        case "checksecurity":
                        case "includedeceased":
                        case "securityenabled":
                        {
                            parms.AddOrReplace(dynamicParm, dynamicParmValue);
                            break;
                        }

                        default:
                        {
                            dynamicFilters.Add(dynamicParm);
                            break;
                        }
                        }
                    }
                }

                parms.AddOrReplace("dynamicparameters", string.Join(",", dynamicFilters));
            }


            return(parms);
        }
예제 #45
0
        /// <summary>
        /// Renders the specified context.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="result">The result.</param>
        /// <exception cref="System.Exception">Your Lava command must contain at least one valid filter. If you configured a filter it's possible that the property or attribute you provided does not exist.</exception>
        public override void Render(Context context, TextWriter result)
        {
            // first ensure that entity commands are allowed in the context
            if (!this.IsAuthorized(context))
            {
                result.Write(string.Format(RockLavaBlockBase.NotAuthorizedMessage, this.Name));
                base.Render(context, result);
                return;
            }

            bool hasFilter = false;

            var modelName = string.Empty;

            // get a service for the entity based off it's friendly name
            if (_entityName == "business")
            {
                modelName = "Rock.Model.Person";
            }
            else
            {
                modelName = "Rock.Model." + _entityName;
            }

            // Check first to see if this is a core model. use the createIfNotFound = false option
            var entityTypeCache = EntityTypeCache.Get(modelName, false);

            if (entityTypeCache == null)
            {
                var entityTypes = EntityTypeCache.All();

                // If not, look for first plug-in model that has same friendly name
                entityTypeCache = entityTypes
                                  .Where(e =>
                                         e.IsEntity &&
                                         !e.Name.StartsWith("Rock.Model") &&
                                         e.FriendlyName != null &&
                                         e.FriendlyName.RemoveSpaces().ToLower() == _entityName)
                                  .OrderBy(e => e.Id)
                                  .FirstOrDefault();

                // If still null check to see if this was a duplicate class and full class name was used as entity name
                if (entityTypeCache == null)
                {
                    modelName       = _entityName.Replace('_', '.');
                    entityTypeCache = entityTypes.Where(e => String.Equals(e.Name, modelName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
                }
            }

            if (entityTypeCache != null)
            {
                Type entityType = entityTypeCache.GetEntityType();
                if (entityType != null)
                {
                    // Get the appropriate database context for this entity type.
                    // Note that this may be different from the standard RockContext if the entity is sourced from a plug-in.
                    var dbContext = Reflection.GetDbContextForEntityType(entityType);

                    // Check if there is a RockContext in the Lava context. If so then use the RockContext passed in.
                    if (dbContext is RockContext)
                    {
                        var lavaContext = context.Registers["RockContext"];

                        if (lavaContext.IsNotNull())
                        {
                            dbContext = (DbContext)lavaContext;
                        }
                    }

                    // Disable change-tracking for this data context to improve performance - objects supplied to a Lava context are read-only.
                    dbContext.Configuration.AutoDetectChangesEnabled = false;

                    // Create an instance of the entity's service
                    IService serviceInstance = Reflection.GetServiceForEntityType(entityType, dbContext);

                    ParameterExpression paramExpression = Expression.Parameter(entityType, "x");
                    Expression          queryExpression = null; // the base expression we'll use to build our query from

                    // Parse markup
                    var parms = ParseMarkup(_markup, context);

                    if (parms.Any(p => p.Key == "id"))
                    {
                        string propertyName = "Id";

                        List <string> selectionParms = new List <string>();
                        selectionParms.Add(PropertyComparisonConversion("==").ToString());
                        selectionParms.Add(parms["id"].ToString());
                        selectionParms.Add(propertyName);

                        var entityProperty = entityType.GetProperty(propertyName);
                        queryExpression = ExpressionHelper.PropertyFilterExpression(selectionParms, paramExpression, propertyName, entityProperty.PropertyType);

                        hasFilter = true;
                    }
                    else
                    {
                        // where clause expression
                        if (parms.Any(p => p.Key == "where"))
                        {
                            queryExpression = ParseWhere(parms["where"], entityType, serviceInstance, paramExpression, entityType, entityTypeCache);

                            if (queryExpression != null)
                            {
                                hasFilter = true;
                            }
                        }

                        // DataView expression
                        if (parms.Any(p => p.Key == "dataview"))
                        {
                            var dataViewId = parms["dataview"].AsIntegerOrNull();

                            if (dataViewId.HasValue)
                            {
                                var dataViewExpression = GetDataViewExpression(dataViewId.Value, serviceInstance, paramExpression, entityTypeCache);

                                if (queryExpression == null)
                                {
                                    queryExpression = dataViewExpression;
                                    hasFilter       = true;
                                }
                                else
                                {
                                    queryExpression = Expression.AndAlso(queryExpression, dataViewExpression);
                                }
                            }
                        }

                        // process dynamic filter expressions (from the query string)
                        if (parms.Any(p => p.Key == "dynamicparameters"))
                        {
                            var dynamicFilters = parms["dynamicparameters"].Split(',')
                                                 .Select(x => x.Trim())
                                                 .Where(x => !string.IsNullOrWhiteSpace(x))
                                                 .ToList();

                            foreach (var dynamicFilter in dynamicFilters)
                            {
                                var dynamicFilterValue      = HttpContext.Current.Request[dynamicFilter];
                                var dynamicFilterExpression = GetDynamicFilterExpression(dynamicFilter, dynamicFilterValue, entityType, serviceInstance, paramExpression);
                                if (dynamicFilterExpression != null)
                                {
                                    if (queryExpression == null)
                                    {
                                        queryExpression = dynamicFilterExpression;
                                        hasFilter       = true;
                                    }
                                    else
                                    {
                                        queryExpression = Expression.AndAlso(queryExpression, dynamicFilterExpression);
                                    }
                                }
                            }
                        }
                    }

                    // Make the query from the expression.

                    /* [2020-10-08] DL
                     * "Get" is intentionally used here rather than "GetNoTracking" to allow lazy-loading of navigation properties from the Lava context.
                     * (Refer https://github.com/SparkDevNetwork/Rock/issues/4293)
                     */
                    MethodInfo getMethod = serviceInstance.GetType().GetMethod("Get", new Type[] { typeof(ParameterExpression), typeof(Expression), typeof(Rock.Web.UI.Controls.SortProperty), typeof(int?) });

                    if (getMethod != null)
                    {
                        // get a listing of ids and build it into the query expression
                        if (parms.Any(p => p.Key == "ids"))
                        {
                            List <int>         value = parms["ids"].ToString().Split(',').Select(int.Parse).ToList();
                            MemberExpression   propertyExpression = Expression.Property(paramExpression, "Id");
                            ConstantExpression constantExpression = Expression.Constant(value, typeof(List <int>));
                            Expression         containsExpression = Expression.Call(constantExpression, typeof(List <int>).GetMethod("Contains", new Type[] { typeof(int) }), propertyExpression);
                            if (queryExpression != null)
                            {
                                queryExpression = Expression.AndAlso(queryExpression, containsExpression);
                            }
                            else
                            {
                                queryExpression = containsExpression;
                            }

                            hasFilter = true;
                        }

                        var getResult   = getMethod.Invoke(serviceInstance, new object[] { paramExpression, queryExpression, null, null });
                        var queryResult = getResult as IQueryable <IEntity>;

                        // process entity specific filters
                        switch (_entityName)
                        {
                        case "person":
                        {
                            queryResult = PersonFilters((IQueryable <Person>)queryResult, parms);
                            break;
                        }

                        case "business":
                        {
                            queryResult = BusinessFilters((IQueryable <Person>)queryResult, parms);
                            break;
                        }
                        }

                        // if there was a dynamic expression add it now
                        if (parms.Any(p => p.Key == "expression"))
                        {
                            queryResult = queryResult.Where(parms["expression"]);
                            hasFilter   = true;
                        }

                        var queryResultExpression = queryResult.Expression;

                        // add sort expressions
                        if (parms.Any(p => p.Key == "sort"))
                        {
                            string orderByMethod = "OrderBy";

                            foreach (var column in parms["sort"].Split(',').Select(x => x.Trim()).Where(x => !string.IsNullOrWhiteSpace(x)).ToList())
                            {
                                string propertyName;
                                var    direction = SortDirection.Ascending;

                                if (column.EndsWith(" desc", StringComparison.OrdinalIgnoreCase))
                                {
                                    direction    = SortDirection.Descending;
                                    propertyName = column.Left(column.Length - 5);
                                }
                                else
                                {
                                    propertyName = column;
                                }

                                string methodName = direction == SortDirection.Descending ? orderByMethod + "Descending" : orderByMethod;

                                if (entityType.GetProperty(propertyName) != null)
                                {
                                    // sorting a entity property
                                    var memberExpression          = Expression.Property(paramExpression, propertyName);
                                    LambdaExpression sortSelector = Expression.Lambda(memberExpression, paramExpression);
                                    queryResultExpression = Expression.Call(typeof(Queryable), methodName, new Type[] { queryResult.ElementType, sortSelector.ReturnType }, queryResultExpression, sortSelector);
                                }
                                else
                                {
                                    // sorting on an attribute

                                    // get attribute id
                                    int?attributeId = null;
                                    foreach (var attribute in AttributeCache.GetByEntityType(entityTypeCache.Id))
                                    {
                                        if (attribute.Key == propertyName)
                                        {
                                            attributeId = attribute.Id;
                                            break;
                                        }
                                    }

                                    if (attributeId.HasValue)
                                    {
                                        // get AttributeValue queryable and parameter
                                        if (dbContext is RockContext)
                                        {
                                            var attributeValues = new AttributeValueService(dbContext as RockContext).Queryable();
                                            ParameterExpression attributeValueParameter = Expression.Parameter(typeof(AttributeValue), "v");
                                            MemberExpression    idExpression            = Expression.Property(paramExpression, "Id");
                                            var attributeExpression = Attribute.Helper.GetAttributeValueExpression(attributeValues, attributeValueParameter, idExpression, attributeId.Value);

                                            LambdaExpression sortSelector = Expression.Lambda(attributeExpression, paramExpression);
                                            queryResultExpression = Expression.Call(typeof(Queryable), methodName, new Type[] { queryResult.ElementType, sortSelector.ReturnType }, queryResultExpression, sortSelector);
                                        }
                                        else
                                        {
                                            throw new Exception(string.Format("The database context for type {0} does not support RockContext attribute value queries.", entityTypeCache.FriendlyName));
                                        }
                                    }
                                }

                                orderByMethod = "ThenBy";
                            }
                        }

                        // check to ensure we had some form of filter (otherwise we'll return all results in the table)
                        if (!hasFilter)
                        {
                            throw new Exception("Your Lava command must contain at least one valid filter. If you configured a filter it's possible that the property or attribute you provided does not exist.");
                        }

                        // reassemble the queryable with the sort expressions
                        queryResult = queryResult.Provider.CreateQuery(queryResultExpression) as IQueryable <IEntity>;

                        if (parms.GetValueOrNull("count").AsBoolean())
                        {
                            int countResult = queryResult.Count();
                            context.Scopes.Last()["count"] = countResult;
                        }
                        else
                        {
                            // Run security check on each result if enabled and entity is not a person (we do not check security on people)
                            if (parms["securityenabled"].AsBoolean() && _entityName != "person")
                            {
                                var items        = queryResult.ToList();
                                var itemsSecured = new List <IEntity>();

                                Person person = GetCurrentPerson(context);

                                foreach (IEntity item in items)
                                {
                                    ISecured itemSecured = item as ISecured;
                                    if (itemSecured == null || itemSecured.IsAuthorized(Authorization.VIEW, person))
                                    {
                                        itemsSecured.Add(item);

                                        /*
                                         *      8/13/2020 - JME
                                         *      It might seem logical to break out of the loop if there is limit parameter provided once the
                                         *  limit is reached. This though has two issues.
                                         *
                                         *  FIRST
                                         *  Depending how it was implemented it can have the effect of breaking when an offset is
                                         *  provided.
                                         *          {% contentchannelitem where:'ContentChannelId == 1' limit:'3' %}
                                         *          {% for item in contentchannelitemItems %}
                                         *              {{ item.Id }} - {{ item.Title }}<br>
                                         *          {% endfor %}
                                         *      {% endcontentchannelitem %}
                                         *  Returns 3 items (correct)
                                         *
                                         *      {% contentchannelitem where:'ContentChannelId == 1' limit:'3' offset:'1' %}
                                         *          {% for item in contentchannelitemItems %}
                                         *              {{ item.Id }} - {{ item.Title }}<br>
                                         *          {% endfor %}
                                         *      {% endcontentchannelitem %}
                                         *  Returns only 2 items (incorrect) - because of the offset
                                         *
                                         *  SECOND
                                         *  If the limit is moved before the security check it's possible that the security checks
                                         *  will remove items and will therefore not give you the amount of items that you asked for.
                                         *
                                         *  Unfortunately this has to be an inefficent process to ensure pagination works. I will also
                                         *  add a detailed note to the documentation to encourage people to disable security checks,
                                         *  especially when used with pagination, in the Lava docs.
                                         */
                                    }
                                }

                                queryResult = itemsSecured.AsQueryable();
                            }

                            // offset
                            if (parms.Any(p => p.Key == "offset"))
                            {
                                queryResult = queryResult.Skip(parms["offset"].AsInteger());
                            }

                            // limit, default to 1000
                            if (parms.Any(p => p.Key == "limit"))
                            {
                                queryResult = queryResult.Take(parms["limit"].AsInteger());
                            }
                            else
                            {
                                queryResult = queryResult.Take(1000);
                            }

                            var resultList = queryResult.ToList();

                            // if there is only one item to return set an alternative non-array based variable
                            if (resultList.Count == 1)
                            {
                                context.Scopes.Last()[_entityName] = resultList.FirstOrDefault();
                            }

                            context.Scopes.Last()[parms["iterator"]] = resultList;
                        }
                    }
                }
            }
            else
            {
                result.Write(string.Format("Could not find a model for {0}.", _entityName));
                base.Render(context, result);
            }

            base.Render(context, result);
        }