Beispiel #1
0
 /// <summary>
 ///     Renders the container.
 /// </summary>
 /// <param name="model">The model.</param>
 /// <param name="outputStream">The output stream.</param>
 /// <exception cref="NotImplementedException">
 ///     Csv Rendering
 ///     Engine has no container
 /// </exception>
 /// TODO Edit XML Comment Template for RenderContainer
 public void RenderContainer(
     ContainerRenderingModel model,
     TextWriter outputStream)
 {
     throw new NotImplementedException(
               "Csv Rendering Engine has no container");
 }
Beispiel #2
0
        /// <summary>
        ///     Renders the container using controller.
        /// </summary>
        /// <param name="gridDefinition">The grid definition.</param>
        /// <param name="helper">The helper.</param>
        /// <param name="model">The model.</param>
        /// <returns>System.String.</returns>
        /// TODO Edit XML Comment Template for RenderContainerUsingController
        private static string RenderContainerUsingController(
            IMvcGridDefinition gridDefinition,
            HtmlHelper helper,
            ContainerRenderingModel model)
        {
            var controllerContext = helper.ViewContext.Controller
                                    .ControllerContext;

            var vdd = new ViewDataDictionary(model);
            var tdd = new TempDataDictionary();

            using (var sw = new StringWriter())
            {
                var viewResult = ViewEngines.Engines.FindPartialView(
                    controllerContext,
                    gridDefinition.ContainerViewPath);

                var viewContext = new ViewContext(
                    controllerContext,
                    viewResult.View,
                    vdd,
                    tdd,
                    sw);

                viewResult.View.Render(viewContext, sw);

                viewResult.ViewEngine.ReleaseView(
                    controllerContext,
                    viewResult.View);

                return(sw.GetStringBuilder().ToString());
            }
        }
Beispiel #3
0
        /// <summary>
        ///     Gets the base page HTML.
        /// </summary>
        /// <param name="helper">The helper.</param>
        /// <param name="gridName">Name of the grid.</param>
        /// <param name="grid">The grid.</param>
        /// <param name="pageParameters">The page parameters.</param>
        /// <returns>System.String.</returns>
        /// TODO Edit XML Comment Template for GetBasePageHtml
        public string GetBasePageHtml(
            HtmlHelper helper,
            string gridName,
            IMvcGridDefinition grid,
            object pageParameters)
        {
            var preload = "";

            if (grid.QueryOnPageLoad &&
                grid.PreloadData)
            {
                try
                {
                    preload = RenderPreloadedGridHtml(
                        helper,
                        grid,
                        gridName,
                        pageParameters);
                }
                catch (Exception ex)
                {
                    var showDetails = ConfigUtility
                                      .GetShowErrorDetailsSetting();

                    if (showDetails)
                    {
                        var detail = "<div class='alert alert-danger'>";

                        detail += HttpUtility.HtmlEncode(ex.ToString())
                                  .Replace("\r\n", "<br />");

                        detail += "</div>";
                        preload = detail;
                    }
                    else
                    {
                        preload = grid.ErrorMessageHtml;
                    }
                }
            }

            var baseGridHtml =
                MvcGridHtmlGenerator.GenerateBasePageHtml(
                    gridName,
                    grid,
                    pageParameters);

            baseGridHtml = baseGridHtml.Replace("%%PRELOAD%%", preload);

            var containerRenderingModel = new ContainerRenderingModel
            {
                InnerHtmlBlock = baseGridHtml
            };

            var html =
                RenderContainerHtml(helper, grid, containerRenderingModel);

            return(html);
        }
Beispiel #4
0
        /// <summary>
        ///     Renders the container using rendering engine.
        /// </summary>
        /// <param name="gridDefinition">The grid definition.</param>
        /// <param name="model">The model.</param>
        /// <returns>System.String.</returns>
        /// TODO Edit XML Comment Template for RenderContainerUsingRenderingEngine
        private static string RenderContainerUsingRenderingEngine(
            IMvcGridDefinition gridDefinition,
            ContainerRenderingModel model)
        {
            var renderingEngine = GetRenderingEngineInternal(gridDefinition);

            using (var ms = new MemoryStream())
            {
                using (TextWriter tw = new StreamWriter(ms))
                {
                    renderingEngine.RenderContainer(model, tw);
                }

                return(LocalEncoding.GetString(ms.ToArray()));
            }
        }
Beispiel #5
0
        public string GetBasePageHtml(string gridName, IMVCGridDefinition grid, object pageParameters)
        {
            string preload = "";

            if (grid.QueryOnPageLoad && grid.PreloadData)
            {
                try
                {
                    preload = RenderPreloadedGridHtml(grid, gridName, pageParameters);
                }
                catch (Exception ex)
                {
                    bool showDetails = ConfigUtility.GetShowErrorDetailsSetting();

                    if (showDetails)
                    {
                        string detail = "<div class='alert alert-danger'>";
                        detail += HttpUtility.HtmlEncode(ex.ToString()).Replace("\r\n", "<br />");
                        detail += "</div>";

                        preload = detail;
                    }
                    else
                    {
                        preload = grid.ErrorMessageHtml;
                    }
                }
            }

            string rootUrl      = HtmlUtility.GetRootUrl();
            string baseGridHtml = MVCGridHtmlGenerator.GenerateBasePageHtml(gridName, grid, pageParameters, HtmlUtility.GetHandlerPath(rootUrl));

            baseGridHtml = baseGridHtml.Replace("%%PRELOAD%%", preload);

            ContainerRenderingModel containerRenderingModel = new ContainerRenderingModel()
            {
                InnerHtmlBlock = baseGridHtml
            };

            string html = RenderContainerHtml(grid, gridName, containerRenderingModel);

            return(html);
        }
Beispiel #6
0
        /// <summary>
        ///     Renders the container HTML.
        /// </summary>
        /// <param name="helper">The helper.</param>
        /// <param name="grid">The grid.</param>
        /// <param name="containerRenderingModel">
        ///     The container
        ///     rendering model.
        /// </param>
        /// <returns>System.String.</returns>
        /// <exception cref="InvalidOperationException"></exception>
        /// <exception cref="Exception">
        ///     When rendering a container, you must output
        ///     Model.InnerHtmlBlock inside the container (Raw).
        /// </exception>
        /// TODO Edit XML Comment Template for RenderContainerHtml
        private static string RenderContainerHtml(
            HtmlHelper helper,
            IMvcGridDefinition grid,
            ContainerRenderingModel containerRenderingModel)
        {
            var container = containerRenderingModel.InnerHtmlBlock;

            switch (grid.RenderingMode)
            {
            case RenderingMode.RenderingEngine:
                GetRenderingEngineInternal(grid);
                container = RenderContainerUsingRenderingEngine(
                    grid,
                    containerRenderingModel);
                break;

            case RenderingMode.Controller:
                if (!string.IsNullOrWhiteSpace(grid.ContainerViewPath))
                {
                    container = RenderContainerUsingController(
                        grid,
                        helper,
                        containerRenderingModel);
                }
                break;

            default: throw new InvalidOperationException();
            }

            if (!container.Contains(containerRenderingModel.InnerHtmlBlock))
            {
                throw new Exception(
                          "When rendering a container, you must output Model.InnerHtmlBlock inside the container (Raw).");
            }

            return(container);
        }
Beispiel #7
0
 private static string RenderContainerUsingController(IMVCGridDefinition gridDefinition /*, HtmlHelper helper*/, ContainerRenderingModel model)
 {
     return(string.Empty);
     //var controllerContext = helper.ViewContext.Controller.ControllerContext;
     //ViewDataDictionary vdd = new ViewDataDictionary(model);
     //TempDataDictionary tdd = new TempDataDictionary();
     //using (var sw = new StringWriter())
     //{
     //    var viewResult = ViewEngines.Engines.FindPartialView(controllerContext,
     //                                                             gridDefinition.ContainerViewPath);
     //    var viewContext = new ViewContext(controllerContext, viewResult.View, vdd, tdd, sw);
     //    viewResult.View.Render(viewContext, sw);
     //    viewResult.ViewEngine.ReleaseView(controllerContext, viewResult.View);
     //    return sw.GetStringBuilder().ToString();
     //}
 }
 public void RenderContainer(ContainerRenderingModel model, TextWriter outputStream)
 {
     outputStream.Write(model.InnerHtmlBlock);
 }