protected virtual Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
        {
            var areaRouteData    = GetAreaRouteDataFromRenderingItem(rendering.RenderingItem);
            var controllerRunner = GetControllerRunner(areaRouteData);

            return(new AreaControllerRenderer(controllerRunner, areaRouteData));
        }
        public override void Process(GetRendererArgs args)
        {
            if (args.Result == null) return;

            if(DiagnosticsEnabled)
                args.Result = new DiagnosticsRenderer(args.Result, args.Rendering);
        }
        private Tuple <string, string> GetFromRenderingItem(Rendering rendering, GetRendererArgs args)
        {
            Template renderingTemplate = args.RenderingTemplate;

            if (renderingTemplate == null)
            {
                return(null);
            }

            if (!renderingTemplate.DescendsFromOrEquals(TemplateIds.ControllerRendering))
            {
                return(null);
            }

            RenderingItem renderingItem = rendering.RenderingItem;

            if (renderingItem == null)
            {
                return(null);
            }

            string controllerName = renderingItem.InnerItem["Controller"];
            string actionName     = renderingItem.InnerItem["Controller Action"];

            if (controllerName.IsWhiteSpaceOrNull())
            {
                controllerName = NameConverter.ConvertItemNameToClassName(renderingItem.Name);
            }

            return(new Tuple <string, string>(controllerName, actionName));
        }
Example #4
0
        private Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
        {
            RenderingItem renderingItem = rendering.RenderingItem;

            if (renderingItem != null && renderingItem.InnerItem.TemplateID == TemplateIds.ControllerRendering)
            {
                string controller = renderingItem.InnerItem[Templates.CDNControllerRendering.Fields.CDNDefaultController];
                string action     = renderingItem.InnerItem[Templates.CDNControllerRendering.Fields.CDNDefaultControllerAction];
                if (controller.IsWhiteSpaceOrNull() || action.IsWhiteSpaceOrNull())
                {
                    return(new ControllerRenderer
                    {
                        ControllerName = "CDN",
                        ActionName = "DefaultLoader"
                    });
                }

                return(new ControllerRenderer
                {
                    ControllerName = controller,
                    ActionName = action
                });
            }

            return(null);
        }
        private Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
        {
            RenderingItem renderingItem = rendering.RenderingItem;

            if (renderingItem != null && renderingItem.InnerItem.TemplateID == TemplateIds.ViewRendering)
            {
                string viewPath = renderingItem.InnerItem[Templates.CDNViewRendering.Fields.CDNDefaultPath];
                if (viewPath.IsWhiteSpaceOrNull())
                {
                    return(new ViewRenderer
                    {
                        ViewPath = "/Views/CDN/DefaultLoader.cshtml",
                        Rendering = rendering
                    });
                }

                return(new ViewRenderer
                {
                    ViewPath = viewPath,
                    Rendering = rendering
                });
            }

            return(null);
        }
        protected Item GetPowershellScript(Rendering rendering, GetRendererArgs args)
        {
            var powershellScript = GetPsScriptFromProperties(rendering) ??
                                   GetPsScriptFromRenderingItem(rendering, args);

            return(powershellScript);
        }
        private Item GetPsScriptFromRenderingItem(Rendering rendering, GetRendererArgs args)
        {
            var renderingTemplate = args.RenderingTemplate;

            if (renderingTemplate == null)
            {
                return(null);
            }
            if (!renderingTemplate.DescendsFromOrEquals(Mvc.Names.TemplateIds.PowershellRendering))
            {
                return(null);
            }
            var renderingItem = rendering.RenderingItem;

            if (renderingItem == null)
            {
                return(null);
            }
            var powershellScript = renderingItem.InnerItem["Powershell Script"];

            if (powershellScript.IsWhiteSpaceOrNull())
            {
                return(null);
            }

            var item = rendering.Item.Database.GetItem(powershellScript);

            return(item);
        }
        protected virtual Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
        {
            var areaRouteData = GetAreaRouteDataFromRenderingItem(rendering.RenderingItem);
            var controllerRunner = GetControllerRunner(areaRouteData);

            return new AreaControllerRenderer(controllerRunner, areaRouteData);
        }
        /// <summary>
        /// Gets tuple object with controller and action from rendering item
        /// </summary>
        /// <param name="rendering">Rendering presentation item</param>
        /// <param name="args">Get renderer arguments</param>
        /// <returns>Tuple object with controller and action</returns>
        protected Tuple <string, string> GetFromRenderingItem(Rendering rendering, GetRendererArgs args)
        {
            var renderingTemplate = args.RenderingTemplate;

            if (renderingTemplate == null)
            {
                return(null);
            }

            if (!renderingTemplate.DescendsFromOrEquals(RenderingsTemplatesIds.ExpTooltipControllerRendering))
            {
                return(null);
            }

            var renderingItem = rendering.RenderingItem;

            if (renderingItem == null)
            {
                return(null);
            }

            var text = renderingItem.InnerItem["Controller"];
            var item = renderingItem.InnerItem["Controller Action"];

            if (text.IsWhiteSpaceOrNull())
            {
                return(null);
            }

            return(new Tuple <string, string>(text, item));
        }
Example #10
0
        protected virtual Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
        {
            Item obj = rendering.Item;

            if (obj == null)
            {
                return(null);
            }

            if (rendering.RenderingType == "Item")
            {
                return(null);
            }

            Template renderingTemplate = args.RenderingTemplate;

            if (renderingTemplate == null)
            {
                return(null);
            }

            if (!renderingTemplate.DescendsFromOrEquals(TemplateIDs.Sublayout) &&
                !renderingTemplate.DescendsFromOrEquals(webControlId))
            {
                return(null);
            }

            return(new UserControlRenderer()
            {
                Rendering = rendering,
                RenderingTemplate = renderingTemplate
            });
        }
 protected override Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
 {
     return(new ViewRenderer
     {
         ViewPath = ExperienceEditorConstants.Views.BlankViewPath,
         Rendering = rendering
     });
 }
 /// <summary>
 /// Processes the specified args.
 /// </summary>
 /// <param name="args">The args.</param>
 public override void Process(GetRendererArgs args)
 {
     if (args.Result != null)
     {
         return;
     }
     args.Result = this.GetRenderer(args.Rendering, args);
 }
        public override void Process(GetRendererArgs args)
        {
            Assert.ArgumentNotNull(args, "args");
            if (args.Result != null)
                return;

            args.Result = GetRenderer(args.Rendering, args);
        }
        protected Tuple <string, string> GetControllerAndAction(Rendering rendering, GetRendererArgs args)
        {
            var tuple = GetFromProperties(rendering) ?? GetFromRenderingItem(rendering, args);

            return(tuple == null
                ? null
                : MvcSettings.ControllerLocator.GetControllerAndAction(tuple.Item1, tuple.Item2));
        }
Example #15
0
 public override void Process(GetRendererArgs args)
 {
     Assert.ArgumentNotNull(args, "args");
     if (args.Result != null)
     {
         return;
     }
     args.Result = GetRenderer(args.Rendering, args);
 }
 protected override Mvc.Presentation.Renderer GetRenderer(Mvc.Presentation.Rendering rendering, GetRendererArgs args)
 {
     Tuple<string, string> controllerAndAction = this.GetControllerAndAction(rendering, args);
     if (!IsChildActionRendering(args.RenderingTemplate) || controllerAndAction == null)
     {
         return null;
     }
     string controller = controllerAndAction.Item1;
     string action = controllerAndAction.Item2;
     return new ChildActionRenderer { ControllerName = controller, ActionName = action };
 }
        public override void Process(GetRendererArgs args)
        {
            if (args.Result == null)
            {
                return;
            }

            if (DiagnosticsEnabled)
            {
                args.Result = new DiagnosticsRenderer(args.Result, args.Rendering);
            }
        }
 /// <summary>
 /// Processes the specified arguments.
 /// </summary>
 /// <param name="args">The arguments.</param>
 public override void Process(GetRendererArgs args)
 {
     if (args.Result != null)
     {
         return;
     }
     if (!args.PageContext?.RequestContext?.HttpContext?.IsHeadless() ?? false)
     {
         return;
     }
     args.Result = new HeadlessRenderer(args.Rendering);
 }
        public override void Process(GetRendererArgs args)
        {
            if (args.Result == null)
            {
                return;
            }

            if (DiagnosticsEnabled && !args.Rendering.RenderingType.Equals("Layout", StringComparison.OrdinalIgnoreCase))
            {
                args.Result = new DiagnosticsRenderer(args.Result, args.Rendering, CreateRenderingDisplayPathResolver());
            }
        }
        }                                                        // Required to test

        public override void Process(GetRendererArgs args)
        {
            if (args.Result != null)
            {
                return;
            }

            if (!IsAreaControllerRendering(args.RenderingTemplate))
            {
                return;
            }

            args.Result = GetRenderer(args.Rendering, args);
        }
Example #21
0
        protected override Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
        {
            var itemToRender = GetItemToRender(rendering, args);

            if (itemToRender == null)
            {
                return(null);
            }
            return(new PresentationTargetsRenderer
            {
                Item = itemToRender,
                Params = args.Rendering.Parameters
            });
        }
Example #22
0
        public override void Process(GetRendererArgs args)
        {
            if (args.Result != null)
            {
                return;
            }

            if (Context.PageMode.IsNormal &&
                !RequestExtensions.IsContextRequestForDynamicData() &&
                args.Rendering.IsAlwaysDynamicallyLoaded())
            {
                args.Result = this.GetRenderer(args.Rendering, args);
            }
        }
        public override void Process(GetRendererArgs args)
        {
            if (args.Result != null)
            {
                return;
            }

            if (! IsAreaControllerRendering(args.RenderingTemplate))
            {
                return;
            }

            args.Result = GetRenderer(args.Rendering, args);
        }
Example #24
0
        /// <summary>
        /// Gets view path from rendering type
        /// </summary>
        /// <param name="rendering">Rendering presentation item</param>
        /// <param name="args">Get renderer arguments</param>
        /// <returns>View path</returns>
        protected new string GetViewPathFromRenderingType(Rendering rendering, GetRendererArgs args)
        {
            if (StringExtensions.EqualsText(rendering.RenderingType, "View"))
            {
                return(this.GetViewPathFromPathProperty(rendering));
            }

            if (StringExtensions.EqualsText(rendering.RenderingType, "Layout"))
            {
                return(this.GetViewPathFromLayoutItem(args));
            }

            return((string)null);
        }
        protected override Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
        {
            Tuple <string, string> controllerAndAction = this.GetControllerAndAction(rendering, args);

            if (controllerAndAction == null)
            {
                return(null);
            }

            return(new WindsorControllerRenderer()
            {
                ControllerName = controllerAndAction.Item1, ActionName = controllerAndAction.Item2
            });
        }
        /// <summary>
        /// The get renderer.
        /// </summary>
        /// <param name="rendering">
        /// The rendering.
        /// </param>
        /// <param name="args">
        /// The args.
        /// </param>
        /// <returns>
        /// The <see cref="Renderer"/>.
        /// </returns>
        protected virtual Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
        {
            var rendererFactory = this.GetControllerRendererFactory();
            if (rendererFactory == null)
            {
                return null;
            }

            var controllerInfo = new ControllerInfo(
                rendering.RenderingItem.InnerItem["controller"],
                rendering.RenderingItem.InnerItem["controller action"],
                rendering.RenderingItem.InnerItem["area"]);

            return rendererFactory.CreateRenderer(controllerInfo);
        }
Example #27
0
        protected virtual Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
        {
            string action         = rendering.RenderingItem.InnerItem.Fields["controller action"].GetValue(true);
            string controller     = rendering.RenderingItem.InnerItem.Fields["controller"].GetValue(true);
            string area           = rendering.RenderingItem.InnerItem.Fields["area"].GetValue(true);
            string namespaceNames = rendering.RenderingItem.InnerItem.Fields["namespace"].GetValue(true);

            return(new AreaControllerRenderer
            {
                Action = action,
                Controller = controller,
                Area = area,
                Namespaces = namespaceNames
            });
        }
Example #28
0
        public override void Process(GetRendererArgs args)
        {
            base.Process(args);

            var viewRendering = args.Result as ViewRenderer;

            if (viewRendering != null)
            {
                args.Result = new SiteViewRenderer
                {
                    ViewPath  = viewRendering.ViewPath,
                    Rendering = viewRendering.Rendering
                };
            }
        }
        /// <summary>
        /// The process.
        /// </summary>
        /// <param name="args">
        /// The args.
        /// </param>
        public override void Process(GetRendererArgs args)
        {
            if (args.Result != null)
            {
                return;
            }

            if (args.RenderingTemplate == null
                || !args.RenderingTemplate.DescendsFromOrEquals(AreaControllerRenderingTemplateId))
            {
                return;
            }

            args.Result = this.GetRenderer(args.Rendering, args);
        }
        protected override Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
        {
            var viewRenderer = base.GetRenderer(rendering, args) as ViewRenderer;
            if (viewRenderer == null)
                return null;

            // Ignore item check when in page editor
            if (Sitecore.Context.PageMode.IsPageEditor || Sitecore.Context.PageMode.IsPageEditorEditing)
                return viewRenderer;

            // Override renderer to null when there is an unpublished item refererenced by underlying view
            return viewRenderer.Rendering.Item != null && viewRenderer.Rendering.RenderingItem.ValueOrDefault(i => i.InnerItem) != null
                ? viewRenderer
                : null;
        }
Example #31
0
        /// <summary>
        /// Gets renderer object
        /// </summary>
        /// <param name="rendering">Rendering presentation item</param>
        /// <param name="args">Get renderer arguments</param>
        /// <returns>Renderer object</returns>
        protected virtual Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
        {
            var viewPath = this.GetViewPath(rendering, args);

            if (StringExtensions.IsWhiteSpaceOrNull(viewPath))
            {
                return((Renderer)null);
            }

            return((Renderer) new ViewRenderer()
            {
                ViewPath = viewPath,
                Rendering = rendering
            });
        }
        protected override Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
        {
            var baseResult = base.GetRenderer(rendering, args);

            if (!SiteHelper.IsValidSite()) return baseResult;

            var viewRenderer = baseResult as ViewRenderer;

            if (viewRenderer == null) return baseResult;

            return new ResilientViewRenderer
            {
                ViewPath = viewRenderer.ViewPath,
                Rendering = viewRenderer.Rendering
            };
        }
        protected override global::Sitecore.Mvc.Presentation.Renderer GetRenderer(
            global::Sitecore.Mvc.Presentation.Rendering rendering, 
            GetRendererArgs args)
        {

            var renderItem = rendering.Item.Database.GetItem(new ID(rendering.RenderingItemPath));
            if (renderItem.TemplateName == "GlassDynamicRazor")
            {
                DynamicViewRenderer render = new DynamicViewRenderer();
                render.Path = renderItem["Name"];
                render.DataSource = rendering.DataSource;
                return render;
            }

            return null;
        }
Example #34
0
        /// <summary>
        /// Gets view path from layout item
        /// </summary>
        /// <param name="args">Get renderer arguments</param>>
        /// <returns>View path</returns>
        private string GetViewPathFromLayoutItem(GetRendererArgs args)
        {
            var path = ObjectExtensions.ValueOrDefault <LayoutItem, string>(args.LayoutItem,
                                                                            (Func <LayoutItem, string>)(item => item.FilePath));

            if (StringExtensions.IsWhiteSpaceOrNull(path))
            {
                return((string)null);
            }

            if (!MvcSettings.IsViewExtension(Path.GetExtension(path)) && StringExtensions.IsAbsoluteViewPath(path))
            {
                return((string)null);
            }

            return(path);
        }
Example #35
0
        /// <summary>
        /// Gets the renderer.
        /// </summary>
        /// <param name="rendering">The rendering.</param>
        /// <param name="args">The args.</param>
        /// <returns>Sitecore.Mvc.Presentation.Renderer.</returns>
        protected override global::Sitecore.Mvc.Presentation.Renderer GetRenderer(
            global::Sitecore.Mvc.Presentation.Rendering rendering,
            GetRendererArgs args)
        {
            var renderItem = rendering.Item.Database.GetItem(new ID(rendering.RenderingItemPath));

            if (renderItem.TemplateName == "GlassDynamicRazor")
            {
                DynamicViewRenderer render = new DynamicViewRenderer();
                render.Path        = renderItem["Name"];
                render.ContextName = renderItem["ContextName"];
                render.DataSource  = rendering.DataSource;
                return(render);
            }

            return(null);
        }
        protected virtual Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
        {
            Tuple <string, string> controllerAndAction = this.GetControllerAndAction(rendering, args);

            if (controllerAndAction == null)
            {
                return(null);
            }
            string str1 = controllerAndAction.Item1;
            string str2 = controllerAndAction.Item2;

            return(new ControllerRenderer()
            {
                ControllerName = str1,
                ActionName = str2
            });
        }
        /// <summary>
        /// Gets renderer object
        /// </summary>
        /// <param name="rendering">Rendering presentation item</param>
        /// <param name="args">Get renderer arguments</param>
        /// <returns>Renderer object</returns>
        protected virtual Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
        {
            var controllerAndAction = this.GetControllerAndAction(rendering, args);

            if (controllerAndAction == null)
            {
                return(null);
            }

            var item  = controllerAndAction.Item1;
            var item2 = controllerAndAction.Item2;

            return(new ControllerRenderer
            {
                ControllerName = item,
                ActionName = item2
            });
        }
        /// <summary>
        /// Gets the renderer.
        /// </summary>
        /// <param name="rendering">The rendering.</param>
        /// <param name="args">The args.</param>
        /// <returns>Sitecore.Mvc.Presentation.Renderer.</returns>
        protected override Sitecore.Mvc.Presentation.Renderer GetRenderer(
            Sitecore.Mvc.Presentation.Rendering rendering, 
            GetRendererArgs args)
        {

            var renderItem = rendering.Item.Database.GetItem(new ID(rendering.RenderingItemPath));
            if (renderItem.TemplateName == "GlassTypedRazor")
            {
                TypedViewRenderer render = new TypedViewRenderer();
                render.Path = renderItem["Name"];
                render.ContextName = renderItem["ContextName"];

                render.DataSource = rendering.DataSource;
                return render;
            }

            return null;
        }
        protected virtual Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
        {
            string action     = rendering.RenderingItem.InnerItem.Fields["controller action"].GetValue(true);
            string controller = rendering.RenderingItem.InnerItem.Fields["controller"].GetValue(true);
            var    area       = rendering.RenderingItem.InnerItem.Fields["area"];
            string areaName   = area != null?area.GetValue(true) : string.Empty;

            var    namespaceName  = rendering.RenderingItem.InnerItem.Fields["namespace"];
            string namespaceNames = namespaceName != null?namespaceName.GetValue(true) : string.Empty;

            return(new AreaControllerRenderer
            {
                Action = action,
                Controller = controller,
                Area = areaName,
                Namespaces = namespaceNames
            });
        }
Example #40
0
        /// <summary>
        /// Gets the renderer.
        /// </summary>
        /// <param name="rendering">The rendering.</param>
        /// <param name="args">The args.</param>
        /// <returns>Sitecore.Mvc.Presentation.Renderer.</returns>
        protected override Sitecore.Mvc.Presentation.Renderer GetRenderer(
            Sitecore.Mvc.Presentation.Rendering rendering,
            GetRendererArgs args)
        {
            if (rendering.Item != null)
            {
                var renderItem = rendering.Item.Database.GetItem(new ID(rendering.RenderingItemPath));
                if (renderItem.TemplateName == "GlassTypedRazor")
                {
                    TypedViewRenderer render = new TypedViewRenderer();
                    render.Path        = renderItem["Name"];
                    render.ContextName = renderItem["ContextName"];

                    render.DataSource = rendering.DataSource;
                    return(render);
                }
            }
            return(null);
        }
Example #41
0
        public override void Process(GetRendererArgs args)
        {
            if (args.Result != null)
            {
                return;
            }

            Template renderingTemplate = args.RenderingTemplate;

            if (renderingTemplate == null)
            {
                return;
            }
            if (!renderingTemplate.DescendsFromOrEquals(new ID(TemplateId)))
            {
                return;
            }
            args.Result = this.GetRenderer(args.Rendering, args);
        }
        /// <summary>
        /// Gets the renderer.
        /// </summary>
        /// <param name="rendering">The rendering.</param>
        /// <param name="args">The args.</param>
        /// <returns>Sitecore.Mvc.Presentation.Renderer.</returns>
        protected override Sitecore.Mvc.Presentation.Renderer GetRenderer(
            Sitecore.Mvc.Presentation.Rendering rendering, 
            GetRendererArgs args)
        {
            if (rendering.Item != null)
            {
                var renderItem = rendering.Item.Database.GetItem(new ID(rendering.RenderingItemPath));
                if (renderItem.TemplateName == "GlassBehindRazor")
                {
                    BehindViewRenderer render = new BehindViewRenderer();
                    render.Path = renderItem["Name"];
                    render.Type = renderItem["Type"];
                    render.Assembly = renderItem["assembly"];

                    render.DataSource = rendering.DataSource;
                    return render;
                }
            }
            return null;
        }
        protected virtual Renderer GetRenderer(Rendering rendering, GetRendererArgs args)
        {
            if (rendering.RenderingItem == null
                || rendering.RenderingItem.InnerItem == null) return null;

            var settings = new RenderingSettings();
            settings.DataSource = rendering.DataSource;
            settings.Parameters = rendering["Parameters"];
            settings.Placeholder = rendering.Placeholder;
            settings.Caching = RenderingCaching.Parse(rendering.RenderingItem.InnerItem);
            settings.Conditions = rendering.RenderingItem.Conditions;
            settings.MultiVariateTest = rendering.RenderingItem.MultiVariateTest;

            var ctrl = rendering.RenderingItem.GetControl(settings);
            if (ctrl != null)
            {
                return new ControlRenderer(ctrl, ""+rendering.UniqueId);
            }

            return null;
        }
 /// <summary>
 /// Gets the renderer.
 /// </summary>
 /// <param name="rendering">The rendering.</param>
 /// <param name="args">The args.</param>
 /// <returns>Sitecore.Mvc.Presentation.Renderer.</returns>
 protected abstract Sitecore.Mvc.Presentation.Renderer GetRenderer(Sitecore.Mvc.Presentation.Rendering rendering, GetRendererArgs args);
 /// <summary>
 /// Processes the specified args.
 /// </summary>
 /// <param name="args">The args.</param>
 public override void Process(GetRendererArgs args)
 {
     if (args.Result != null)
         return;
     args.Result = GetRenderer(args.Rendering, args);
 }
 public void SetUp()
 {
     _args = new GetRendererArgs(new Rendering());
     _controller = new AreaController();
 }