public void FindPartialViewAggregatesAllSearchedLocationsIfAllEnginesFail()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection viewEngineCollection = new ViewEngineCollection();
            Mock<IViewEngine> engine1 = new Mock<IViewEngine>();
            ViewEngineResult engine1Result = new ViewEngineResult(new[] { "location1", "location2" });
            engine1.Setup(e => e.FindPartialView(context, "partial", It.IsAny<bool>())).Returns(engine1Result);
            Mock<IViewEngine> engine2 = new Mock<IViewEngine>();
            ViewEngineResult engine2Result = new ViewEngineResult(new[] { "location3", "location4" });
            engine2.Setup(e => e.FindPartialView(context, "partial", It.IsAny<bool>())).Returns(engine2Result);
            viewEngineCollection.Add(engine1.Object);
            viewEngineCollection.Add(engine2.Object);

            // Act
            ViewEngineResult result = viewEngineCollection.FindPartialView(context, "partial");

            // Assert
            Assert.Null(result.View);
            Assert.Equal(4, result.SearchedLocations.Count());
            Assert.True(result.SearchedLocations.Contains("location1"));
            Assert.True(result.SearchedLocations.Contains("location2"));
            Assert.True(result.SearchedLocations.Contains("location3"));
            Assert.True(result.SearchedLocations.Contains("location4"));
        }
        public void SearchedLocationsProperty()
        {
            // Arrange
            string[] searchedLocations = new string[0];
            ViewEngineResult result = new ViewEngineResult(searchedLocations);

            // Act & Assert
            Assert.Same(searchedLocations, result.SearchedLocations);
            Assert.Null(result.View);
        }
        public void ViewEngineProperty()
        {
            // Arrange
            IView view = new Mock<IView>().Object;
            IViewEngine viewEngine = new Mock<IViewEngine>().Object;
            ViewEngineResult result = new ViewEngineResult(view, viewEngine);

            // Act & Assert
            Assert.Same(viewEngine, result.ViewEngine);
            Assert.Null(result.SearchedLocations);
        }
Esempio n. 4
0
        public override ViewEngineResult FindPartialView(ControllerContext controllerContext, string partialViewName, bool useCache)
        {
            ViewEngineResult result = FindThemeablePartialView(controllerContext, partialViewName, useCache);

            return(result);
        }
Esempio n. 5
0
        private bool ViewExists(string name)
        {
            ViewEngineResult result = ViewEngines.Engines.FindView(ControllerContext, name, null);

            return(result.View != null);
        }
        public void FindPartialViewDelegatesToResolver()
        {
            // Arrange
            Mock<IView> view = new Mock<IView>();
            ControllerContext context = new ControllerContext();
            Mock<IViewEngine> locatedEngine = new Mock<IViewEngine>();
            ViewEngineResult engineResult = new ViewEngineResult(view.Object, locatedEngine.Object);
            locatedEngine.Setup(e => e.FindPartialView(context, "ViewName", true))
                .Returns(engineResult);
            Mock<IViewEngine> secondEngine = new Mock<IViewEngine>();
            Resolver<IEnumerable<IViewEngine>> resolver = new Resolver<IEnumerable<IViewEngine>> { Current = new IViewEngine[] { locatedEngine.Object, secondEngine.Object } };
            ViewEngineCollection engines = new ViewEngineCollection(resolver);

            // Act
            ViewEngineResult result = engines.FindPartialView(context, "ViewName");

            // Assert
            Assert.Same(engineResult, result);
            secondEngine.Verify(e => e.FindPartialView(context, "ViewName", It.IsAny<bool>()), Times.Never());
        }
Esempio n. 7
0
        /// <summary>
        /// Locates and renders a view specified by <see cref="ViewName"/>. If <see cref="ViewName"/> is <c>null</c>,
        /// then the view name searched for is<c>&quot;Default&quot;</c>.
        /// </summary>
        /// <param name="context">The <see cref="ViewComponentContext"/> for the current component execution.</param>
        /// <returns>A <see cref="Task"/> which will complete when view rendering is completed.</returns>
        public async Task ExecuteAsync(ViewComponentContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            var viewEngine            = ViewEngine ?? ResolveViewEngine(context);
            var viewContext           = context.ViewContext;
            var isNullOrEmptyViewName = string.IsNullOrEmpty(ViewName);

            ViewEngineResult     result            = null;
            IEnumerable <string> originalLocations = null;

            if (!isNullOrEmptyViewName)
            {
                // If view name was passed in is already a path, the view engine will handle this.
                result            = viewEngine.GetView(viewContext.ExecutingFilePath, ViewName, isMainPage: false);
                originalLocations = result.SearchedLocations;
            }

            if (result == null || !result.Success)
            {
                // This will produce a string like:
                //
                //  Components/Cart/Default
                //
                // The view engine will combine this with other path info to search paths like:
                //
                //  Views/Shared/Components/Cart/Default.cshtml
                //  Views/Home/Components/Cart/Default.cshtml
                //  Areas/Blog/Views/Shared/Components/Cart/Default.cshtml
                //
                // This supports a controller or area providing an override for component views.
                var viewName          = isNullOrEmptyViewName ? DefaultViewName : ViewName;
                var qualifiedViewName = string.Format(
                    CultureInfo.InvariantCulture,
                    ViewPathFormat,
                    context.ViewComponentDescriptor.ShortName,
                    viewName);

                result = viewEngine.FindView(viewContext, qualifiedViewName, isMainPage: false);
            }

            var view = result.EnsureSuccessful(originalLocations).View;

            using (view as IDisposable)
            {
                if (_diagnosticSource == null)
                {
                    _diagnosticSource = viewContext.HttpContext.RequestServices.GetRequiredService <DiagnosticSource>();
                }

                _diagnosticSource.ViewComponentBeforeViewExecute(context, view);

                var childViewContext = new ViewContext(
                    viewContext,
                    view,
                    ViewData ?? context.ViewData,
                    context.Writer);
                await view.RenderAsync(childViewContext);

                _diagnosticSource.ViewComponentAfterViewExecute(context, view);
            }
        }
Esempio n. 8
0
    /*==========================================================================================================================
    | METHOD: FIND VIEW
    \-------------------------------------------------------------------------------------------------------------------------*/
    /// <summary>
    ///   Loops through potential sources for views to identify the most appropriate <see cref="RazorView"/>.
    /// </summary>
    /// <remarks>
    ///   Will look for a view, in order, from the query string (<code>?View=</code>), <see cref="HttpRequest.Headers"/>
    ///   collection (for matches in the <code>accepts</code> header), then the <see cref="Topic.View"/> property, if set, and
    ///   finally falls back to the <see cref="Topic.ContentType"/>. If none of those yield any results, will default to a
    ///   content type of "Page", which expects to find <code>~/Views/Page/Page.cshtml</code>.
    /// </remarks>
    protected override ViewEngineResult FindView(ControllerContext context) {

      /*------------------------------------------------------------------------------------------------------------------------
      | Validate parameters
      \-----------------------------------------------------------------------------------------------------------------------*/
      Contract.Requires(context, nameof(context));

      /*------------------------------------------------------------------------------------------------------------------------
      | Set variables
      \-----------------------------------------------------------------------------------------------------------------------*/
      var                       contentType                     = _contentType;
      var                       viewEngine                      = ViewEngines.Engines;
      var                       requestContext                  = context.HttpContext.Request;
      var                       view                            = new ViewEngineResult(Array.Empty<string>());
      var                       searchedPaths                   = new List<string>();

      /*------------------------------------------------------------------------------------------------------------------------
      | Check Querystring
      >-------------------------------------------------------------------------------------------------------------------------
      | Determines if the view is defined in the querystring.
      \-----------------------------------------------------------------------------------------------------------------------*/
      if (view.View == null && requestContext.QueryString.AllKeys.Contains("View")) {
        var queryStringValue = requestContext.QueryString["View"];
        if (queryStringValue != null) {
          view = viewEngine.FindView(context, queryStringValue, MasterName);
          searchedPaths = searchedPaths.Union(view.SearchedLocations?? Array.Empty<string>()).ToList();
        }
      }

      /*------------------------------------------------------------------------------------------------------------------------
      | Pull Headers
      \-----------------------------------------------------------------------------------------------------------------------*/
      if (view.View == null && requestContext.Headers.AllKeys.Contains("Accept")) {
        var acceptHeaders = requestContext.Headers.GetValues("Accept");
        // Validate the content-type after the slash, then validate it against available views
        var splitHeaders = acceptHeaders[0].Split(new char[] { ',', ';' });
        // Validate the content-type after the slash, then validate it against available views
        for (var i = 0; i < splitHeaders.Length; i++) {
          if (splitHeaders[i].IndexOf("/", StringComparison.InvariantCultureIgnoreCase) >= 0) {
            // Get content-type after the slash and replace '+' characters in the content-type to '-' for view file encoding
            // purposes
            var acceptHeader = splitHeaders[i]
              .Substring(splitHeaders[i].IndexOf("/", StringComparison.InvariantCulture) + 1)
              .Replace("+", "-");
            // Validate against available views; if content-type represents a valid view, stop validation
            if (acceptHeader != null) {
              view = viewEngine.FindView(context, acceptHeader, MasterName);
              searchedPaths = searchedPaths.Union(view.SearchedLocations ?? Array.Empty<string>()).ToList();
            }
            if (view != null) {
              break;
            }
          }
        }
      }

      /*------------------------------------------------------------------------------------------------------------------------
      | Pull from topic attribute
      >-------------------------------------------------------------------------------------------------------------------------
      | Pull from Topic's View Attribute; additional check against the Topic's ContentType Topic View Attribute is not necessary
      | as it is set as the default View value for the Topic
      \-----------------------------------------------------------------------------------------------------------------------*/
      if (view.View == null && !String.IsNullOrEmpty(_topicView)) {
        view = viewEngine.FindView(context, _topicView, MasterName);
        searchedPaths = searchedPaths.Union(view.SearchedLocations ?? Array.Empty<string>()).ToList();
      }

      /*------------------------------------------------------------------------------------------------------------------------
      | Default to content type
      \-----------------------------------------------------------------------------------------------------------------------*/
      if (view.View == null) {
        view = viewEngine.FindView(context, contentType, MasterName);
        searchedPaths = searchedPaths.Union(view.SearchedLocations ?? Array.Empty<string>()).ToList();
      }

      /*------------------------------------------------------------------------------------------------------------------------
      | Attempt default search
      \-----------------------------------------------------------------------------------------------------------------------*/
      if (view.View == null) {
        view = base.FindView(context);
        searchedPaths = searchedPaths.Union(view.SearchedLocations ?? Array.Empty<string>()).ToList();
      }

      /*------------------------------------------------------------------------------------------------------------------------
      | Return view, if found
      \-----------------------------------------------------------------------------------------------------------------------*/
      if (view.View != null) {
        return view;
      }
      return new ViewEngineResult(searchedPaths);

    }
        internal void Render(RenderingContext context, TextWriter writer)
        {
            string text = context.Content[context.PropertyName] as string;

            if (text == null)
            {
                return;
            }

            var tokens = context.Content.GetDetailCollection(context.PropertyName + CollectionSuffix, false);

            if (tokens != null)
            {
                int lastFragmentEnd = 0;

                foreach (var detail in tokens.Details)
                {
                    var token = detail.ExtractToken();

                    if (lastFragmentEnd < token.Index)
                    {
                        writer.Write(text.Substring(lastFragmentEnd, token.Index - lastFragmentEnd));
                    }

                    ViewEngineResult vr = null;
                    if (context.Html.ViewContext.HttpContext.IsCustomErrorEnabled)
                    {
                        try
                        {
                            vr = ViewEngines.Engines.FindPartialView(context.Html.ViewContext, "TokenTemplates/" + token.Name);
                        }
                        catch (System.Exception ex)
                        {
                            logger.Error(ex);
                        }
                    }
                    else
                    {
                        vr = ViewEngines.Engines.FindPartialView(context.Html.ViewContext, "TokenTemplates/" + token.Name);                         // duplicated to preserve stack trace
                    }

                    if (vr != null && vr.View != null)
                    {
                        var viewData = new ViewDataDictionary(token.Value)
                        {
                            { "ParentViewContext", context.Html.ViewContext }
                        };
                        viewData[RenderingExtensions.ContextKey] = context;
                        viewData[RenderingExtensions.TokenKey]   = token;
                        var vc = new ViewContext(context.Html.ViewContext, vr.View, viewData, context.Html.ViewContext.TempData, writer);
                        vr.View.Render(vc, writer);
                    }
                    else
                    {
                        writer.Write(detail.StringValue);
                    }

                    lastFragmentEnd = token.Index + detail.StringValue.Length;
                }

                if (lastFragmentEnd < text.Length)
                {
                    writer.Write(text.Substring(lastFragmentEnd, text.Length - lastFragmentEnd));
                }
            }
            else
            {
                writer.Write(text);
            }
        }
Esempio n. 10
0
 public ViewEngineResult FindView(ActionContext context, string viewName, bool isMainPage)
 {
     return(ViewEngineResult.Found(viewName, new MainView()));
 }
Esempio n. 11
0
        // --------------------------------------------------------------------------------------------------------------------

        ViewEngineResult IViewPageRenderEvents.OnViewFound(ActionContext actionContext, ViewEngineResult searchResult)
        {
            return(OnViewFound(actionContext, searchResult));
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="context"></param>
        /// <param name="viewName"></param>
        /// <param name="viewData"></param>
        /// <param name="model"></param>
        /// <param name="tempData"></param>
        /// <param name="idMode"></param>
        /// <param name="controlId"></param>
        /// <returns></returns>
        public virtual string Render(ControllerContext context, string viewName, ViewDataDictionary viewData, object model, TempDataDictionary tempData, IDMode idMode, string controlId)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            if (String.IsNullOrEmpty(viewName))
            {
                viewName = context.RouteData.GetRequiredString("action");
            }

            string id = controlId ?? "ID_" + Guid.NewGuid().ToString().Replace("-", "");
            string ct = "ID_" + Guid.NewGuid().ToString().Replace("-", "");

            ViewDataDictionary newViewData = null;

            if (model == null)
            {
                if (viewData == null)
                {
                    newViewData = new ViewDataDictionary();
                }
                else
                {
                    newViewData = new ViewDataDictionary(viewData);
                }
            }
            else
            {
                if (viewData == null)
                {
                    newViewData = new ViewDataDictionary(model);
                }
                else
                {
                    newViewData = new ViewDataDictionary(viewData)
                    {
                        Model = model
                    };
                }
            }

            ViewEngineResult result = ViewEngines.Engines.FindPartialView(context, viewName);
            IView            view   = result.View;

            if (view is RazorView)
            {
                throw new Exception("Please use standard Html.RenderPartial or Html.Partial under Razor engine");
            }

            string path = ((WebFormView)view).ViewPath;

            ViewContext viewContext = new ViewContext(context, view, newViewData, tempData ?? new TempDataDictionary(), context.HttpContext.Response.Output);

            PartialViewPage pageHolder = new PartialViewPage
            {
                ViewData    = newViewData,
                ViewContext = viewContext
            };

            var curRM = HttpContext.Current.Items[typeof(ResourceManager)];

            HttpContext.Current.Items[typeof(ResourceManager)] = null;
            object oldPageRM = null;

            if (context.HttpContext.CurrentHandler is Page)
            {
                oldPageRM = ((Page)HttpContext.Current.CurrentHandler).Items[typeof(ResourceManager)];
                ((Page)HttpContext.Current.CurrentHandler).Items[typeof(ResourceManager)] = null;
            }

            ResourceManager rm = new ResourceManager();

            rm.RenderScripts = ResourceLocationType.None;
            rm.RenderStyles  = ResourceLocationType.None;
            rm.IDMode        = idMode;
            pageHolder.Controls.Add(rm);
            Panel p = new Panel {
                ID = id, IDMode = idMode, Border = false, Header = false
            };

            pageHolder.Controls.Add(p);

            ViewUserControl uc = (ViewUserControl)pageHolder.LoadControl(path);

            uc.ID       = id + "_UC";
            uc.ViewData = newViewData;
            p.ContentControls.Add(uc);

            pageHolder.InitHelpers();

            string wScript = DefaultScriptBuilder.Create(p).Build(RenderMode.RenderTo, ct, null, true, true);
            string script  = string.Format("<div id=\"{0}\"></div><script type=\"text/javascript\">Ext.onReady(function(){{{1}}});</script>", ct, wScript);

            IDisposable disposable = view as IDisposable;

            if (disposable != null)
            {
                disposable.Dispose();
            }

            HttpContext.Current.Items[typeof(ResourceManager)] = curRM;
            if (context.HttpContext.CurrentHandler is Page)
            {
                ((Page)HttpContext.Current.CurrentHandler).Items[typeof(ResourceManager)] = oldPageRM;
            }

            return(script);
        }
Esempio n. 13
0
 public ActionResult NoTheme(ViewEngineResult viewResult)
 {
     return View("NoTheme", viewResult);
 }
Esempio n. 14
0
 protected virtual ViewEngineResult OnViewFound(ActionContext actionContext, ViewEngineResult searchResult)
 {
     return(null);
 }
 public PDFView(ViewEngineResult result, string fileName)
 {
     this._result   = result;
     this._fileName = fileName;
 }
Esempio n. 16
0
        /// <summary>
        /// Attempts to find the <see cref="IView"/> associated with <paramref name="viewResult"/>.
        /// </summary>
        /// <param name="actionContext">The <see cref="ActionContext"/> associated with the current request.</param>
        /// <param name="viewResult">The <see cref="PartialViewResult"/>.</param>
        /// <returns>A <see cref="ViewEngineResult"/>.</returns>
        public virtual ViewEngineResult FindView(ActionContext actionContext, PartialViewResult viewResult)
        {
            if (actionContext == null)
            {
                throw new ArgumentNullException(nameof(actionContext));
            }

            if (viewResult == null)
            {
                throw new ArgumentNullException(nameof(viewResult));
            }

            var viewEngine = viewResult.ViewEngine ?? ViewEngine;
            var viewName   = viewResult.ViewName ?? actionContext.ActionDescriptor.Name;

            var result         = viewEngine.GetView(executingFilePath: null, viewPath: viewName, isMainPage: false);
            var originalResult = result;

            if (!result.Success)
            {
                result = viewEngine.FindView(actionContext, viewName, isMainPage: false);
            }

            if (!result.Success)
            {
                if (originalResult.SearchedLocations.Any())
                {
                    if (result.SearchedLocations.Any())
                    {
                        // Return a new ViewEngineResult listing all searched locations.
                        var locations = new List <string>(originalResult.SearchedLocations);
                        locations.AddRange(result.SearchedLocations);
                        result = ViewEngineResult.NotFound(viewName, locations);
                    }
                    else
                    {
                        // GetView() searched locations but FindView() did not. Use first ViewEngineResult.
                        result = originalResult;
                    }
                }
            }

            if (result.Success)
            {
                DiagnosticSource.ViewFound(
                    actionContext,
                    isMainPage: false,
                    viewResult: viewResult,
                    viewName: viewName,
                    view: result.View);

                Logger.PartialViewFound(viewName);
            }
            else
            {
                DiagnosticSource.ViewNotFound(
                    actionContext,
                    isMainPage: false,
                    viewResult: viewResult,
                    viewName: viewName,
                    searchedLocations: result.SearchedLocations);

                Logger.PartialViewNotFound(viewName, result.SearchedLocations);
            }

            return(result);
        }
Esempio n. 17
0
        protected bool ViewExists(ControllerContext ctx, string name)
        {
            ViewEngineResult result = ViewEngines.Engines.FindView(ctx, name, null);

            return(result.View != null);
        }
        public void FindViewIteratesThroughCollectionUntilFindsSuccessfulEngine()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();
            Mock<IViewEngine> engine1 = new Mock<IViewEngine>();
            ViewEngineResult engine1Result = new ViewEngineResult(new[] { "location1", "location2" });
            engine1.Setup(e => e.FindView(context, "view", "master", It.IsAny<bool>())).Returns(engine1Result);
            Mock<IViewEngine> engine2 = new Mock<IViewEngine>();
            ViewEngineResult engine2Result = new ViewEngineResult(new Mock<IView>().Object, engine2.Object);
            engine2.Setup(e => e.FindView(context, "view", "master", It.IsAny<bool>())).Returns(engine2Result);
            collection.Add(engine1.Object);
            collection.Add(engine2.Object);

            // Act
            ViewEngineResult result = collection.FindView(context, "view", "master");

            // Assert
            Assert.Same(engine2Result, result);
        }
        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }
            // Set the model and data
            context.Controller.ViewData.Model = Model;
            ViewData = context.Controller.ViewData;
            TempData = context.Controller.TempData;

            // Get the view name
            if (string.IsNullOrEmpty(ViewName))
            {
                ViewName = context.RouteData.GetRequiredString("action");
            }

            // Get the view
            ViewEngineResult viewEngineResult = null;

            if (View == null)
            {
                viewEngineResult = FindView(context);
                View             = viewEngineResult.View;
            }

            // Render the view
            var sb = new StringBuilder();

            using (TextWriter tr = new StringWriter(sb))
            {
                var viewContext = new ViewContext(context, View, ViewData, TempData, tr);
                View.Render(viewContext, tr);
            }

            viewEngineResult?.ViewEngine.ReleaseView(context, View);
            var scheme = (context.RequestContext.HttpContext.Request.Url != null) ?
                         context.RequestContext.HttpContext.Request.Url.Scheme : "http";
            var baseUri =
                $"{scheme}://{context.RequestContext.HttpContext.Request.Url.Authority}{context.RequestContext.HttpContext.Request.ApplicationPath}/";

            // Load HTML file
            if (Options == null)
            {
                Options = new Aspose.Pdf.HtmlLoadOptions(baseUri);
            }


            var pdfDocument = new Document(new MemoryStream(Encoding.UTF8.GetBytes(sb.ToString())), Options);

            using (var streamOut = new MemoryStream())
            {
                pdfDocument.Save(streamOut);
                streamOut.Seek(0, SeekOrigin.Begin);
                var result = new FileContentResult(streamOut.ToArray(), "application/pdf")
                {
                    FileDownloadName = FileDownloadName
                };
                result.ExecuteResult(context);
            }
        }
        public void FindViewSuccessWithOneEngine()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();
            Mock<IViewEngine> engine = new Mock<IViewEngine>();
            ViewEngineResult engineResult = new ViewEngineResult(new Mock<IView>().Object, engine.Object);
            engine.Setup(e => e.FindView(context, "view", "master", It.IsAny<bool>())).Returns(engineResult);
            collection.Add(engine.Object);

            // Act
            ViewEngineResult result = collection.FindView(context, "view", "master");

            // Assert
            Assert.Same(engineResult, result);
        }
Esempio n. 21
0
 public ViewEngineResult GetView(string executingFilePath, string viewPath,
                                 bool isMainPage)
 {
     return(ViewEngineResult.NotFound(viewPath,
                                      new string[] { "(Debug View Engine - GetView)" }));
 }
Esempio n. 22
0
        private ViewTemplateDescription RenderViewForRegistration(VirtualFile file, Type modelType, ControllerContext cctx, ViewEngineResult result)
        {
            var re = new ContentRegistration();

            re.ContentType = modelType;
            re.Template    = N2.Web.Url.RemoveAnyExtension(file.Name);
            re.IsDefined   = false;
            using (StringWriter sw = new StringWriter())
            {
                var vdd = new ViewDataDictionary();
                cctx.Controller.ViewData      = vdd;
                vdd["RegistrationExpression"] = re;

                try
                {
                    result.View.Render(new ViewContext(cctx, result.View, vdd, new TempDataDictionary(), sw), sw);
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(ex);
                    if (re.IsDefined)
                    {
                        throw;
                    }
                    return(null);
                }

                if (re.IsDefined)
                {
                    return(new ViewTemplateDescription
                    {
                        Registration = re,
                        Definition = GetOrCreateDefinition(re),
                        TouchedPaths = new[] { file.VirtualPath }.Union(re.TouchedPaths)
                    });
                }
                return(null);
            }
        }
Esempio n. 23
0
        public override void OnActionExecuted(ActionExecutedContext filterContext)
        {
            MultiFormatActionResult multiFormatResult = filterContext.Result as MultiFormatActionResult;

            if (multiFormatResult == null)
            {
                ViewResultBase viewResult = filterContext.Result as ViewResultBase;
                if (viewResult != null && viewResult.ViewData != null)
                {
                    bool handled = false;
                    foreach (ContentType responseFormat in filterContext.RequestContext.GetResponseFormats())
                    {
                        // CONSIDER: making this lookup optional if perf is an issue
                        for (int i = 0; i < FormatManager.Current.ResponseFormatHandlers.Count; ++i)
                        {
                            IResponseFormatHandler handler = FormatManager.Current.ResponseFormatHandlers[i];
                            if (handler.CanSerialize(responseFormat))
                            {
                                // we can't use the full ContentType's name (EG: "text/xml")
                                // instead we use the FriendlyName on the matching IResponseFormatHandler
                                string friendlyName = handler.FriendlyName;
                                string viewName     = viewResult.ViewName;
                                if (String.IsNullOrEmpty(viewName))
                                {
                                    viewName = filterContext.RouteData.GetRequiredString("action");
                                }
                                // CONSIDER: is this naming convention sufficient? look at extensibility (how can I customize the FindView process?)
                                viewName = viewName + "." + friendlyName;
                                // CONSIDER: ViewEngineCollection queries view engines in registration order and returns 1st match,
                                // would it make sense to let the client provide a hint in case
                                ViewEngineResult result = viewResult.ViewEngineCollection.FindView(filterContext, viewName, null);
                                // ignore errors and fallback to default behavior
                                if (result != null && result.View != null)
                                {
                                    Encoding encoding = Encoding.UTF8;
                                    if (!String.IsNullOrEmpty(responseFormat.CharSet))
                                    {
                                        try
                                        {
                                            encoding = Encoding.GetEncoding(responseFormat.CharSet);
                                        }
                                        catch (ArgumentException)
                                        {
                                            throw new HttpException((int)HttpStatusCode.NotAcceptable, String.Format(CultureInfo.CurrentCulture, MvcResources.Resources_UnsupportedFormat, responseFormat));
                                        }
                                    }
                                    responseFormat.CharSet = encoding.HeaderName;
                                    filterContext.HttpContext.Response.ContentType     = responseFormat.ToString();
                                    filterContext.HttpContext.Response.ContentEncoding = encoding;
                                    // we have set the Response.ContentType but know that the webforms view engine will override it
                                    // a different ViewPage base class that sets this can be used to workaround this
                                    // so we make the computed responseFormat available in ViewData
                                    viewResult.ViewData[DefaultFormatHelper.ResponseFormatKey] = responseFormat;
                                    viewResult.View     = result.View;
                                    viewResult.ViewName = viewName;
                                    handled             = true;
                                    break;
                                }
                            }
                        }
                        if (handled)
                        {
                            break;
                        }
                        if (TryGetResult(viewResult, responseFormat, out multiFormatResult))
                        {
                            if (multiFormatResult != null)
                            {
                                filterContext.Result = multiFormatResult;
                            }
                            handled = true;
                            break;
                        }
                    }
                    if (!handled)
                    {
                        // if enumeration doesn't yield a handler the request is not acceptable
                        // CONSIDER: returning all formats considered in the exception messages
                        throw new HttpException((int)HttpStatusCode.NotAcceptable, "None of the formats specified by the accept header is supported.");
                    }
                }
            }
            base.OnActionExecuted(filterContext);
            RedirectToRouteResult redirectResult = filterContext.Result as RedirectToRouteResult;

            if (redirectResult != null && !filterContext.RequestContext.IsBrowserRequest())
            {
                filterContext.Result = new ResourceRedirectToRouteResult(redirectResult);
            }
        }
Esempio n. 24
0
 public ViewEngineResult GetView(string executingFilePath, string viewPath, bool isMainPage)
 {
     return(ViewEngineResult.Found("vidok", new MainView()));
 }
Esempio n. 25
0
        public void TestGenerate()
        {
            var request = new Mock <HttpRequestBase>();
            var mock    = new Mock <ControllerContext>();

            request.SetupGet(x => x.Headers).Returns(
                new System.Net.WebHeaderCollection {
                { "X-Requested-With", "XMLHttpRequest" }
            });

            var context = new Mock <HttpContextBase>();

            context.SetupGet(x => x.Request).Returns(request.Object);

            mock.SetupGet(p => p.HttpContext.User.Identity.Name).Returns("test");
            if ("test" != null)
            {
                mock.SetupGet(p => p.HttpContext.Request.IsAuthenticated).Returns(true);
                mock.SetupGet(p => p.HttpContext.User.Identity.IsAuthenticated).Returns(true);
            }
            //else
            //{
            //    mock.SetupGet(p => p.HttpContext.Request.IsAuthenticated).Returns(false);
            //}

            var routeData = new RouteData();

            routeData.Values.Add("controller", "MessagesController");
            routeData.Values.Add("action", "GetMessage");
            mock.SetupGet(m => m.RouteData).Returns(routeData);

            var view             = new Mock <IView>();
            var engine           = new Mock <IViewEngine>();
            var viewEngineResult = new ViewEngineResult(view.Object, engine.Object);

            engine.Setup(e => e.FindPartialView(It.IsAny <ControllerContext>(), It.IsAny <string>(), It.IsAny <bool>())).Returns(viewEngineResult);
            ViewEngines.Engines.Clear();
            ViewEngines.Engines.Add(engine.Object);

            MessagesController controller = new MessagesController(new EventService());

            controller.ControllerContext = new ControllerContext(context.Object, routeData, controller);

            var vm = new ChatMessageViewModel()
            {
                From = new Models.Database.User()
                {
                },
                To = new Models.Database.User()
                {
                },
                IsReceived = true,
                Message    = new UserMessage()
                {
                    From = new Models.Database.User()
                    {
                        Name = "FromSender", AppId = "123"
                    }, TimeStamp = DateTime.Now, Content = "This is a test message!"
                },
            };

            var HTMLString = controller.RenderPartialViewToString(viewName: "_PartialChatMessage", model: vm);

            var pm = new PreMailer.Net.PreMailer(HTMLString);
        }
Esempio n. 26
0
        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            // Set the model and data
            context.Controller.ViewData.Model = Model;
            ViewData = context.Controller.ViewData;
            TempData = context.Controller.TempData;


            // Get the view name
            if (string.IsNullOrEmpty(ViewName))
            {
                ViewName = context.RouteData.GetRequiredString("action");
            }

            // Get the view
            ViewEngineResult viewEngineResult = null;

            if (View == null)
            {
                viewEngineResult = FindView(context);
                View             = viewEngineResult.View;
            }

            // Render the view
            StringBuilder sb = new StringBuilder();

            using (TextWriter tr = new StringWriter(sb))
            {
                ViewContext viewContext = new ViewContext(context, View, ViewData, TempData, tr);
                View.Render(viewContext, tr);
            }
            if (viewEngineResult != null)
            {
                viewEngineResult.ViewEngine.ReleaseView(context, View);
            }

            // Create a PDF from the rendered view content
            var       workStream = new MemoryStream();
            var       document   = new Document();
            PdfWriter writer     = PdfWriter.GetInstance(document, workStream);

            writer.CloseStream = false;
            document.Open();
            Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(sb.ToString()));

            XMLWorkerHelper.GetInstance().ParseXHtml(writer, document, stream, null as Stream);
            document.Close();

            // Save the PDF to the response stream
            FileContentResult result = new FileContentResult(workStream.ToArray(), "application/pdf")
            {
                FileDownloadName = FileDownloadName
            };

            result.ExecuteResult(context);
        }
Esempio n. 27
0
        /// <summary>
        /// Attempts to find the <see cref="IView"/> associated with <paramref name="viewResult"/>.
        /// </summary>
        /// <param name="actionContext">The <see cref="ActionContext"/> associated with the current request.</param>
        /// <param name="viewResult">The <see cref="ViewResult"/>.</param>
        /// <returns>A <see cref="ViewEngineResult"/>.</returns>
        public virtual ViewEngineResult FindView(ActionContext actionContext, PdfResult viewResult)
        {
            if (actionContext == null)
            {
                throw new ArgumentNullException(nameof(actionContext));
            }

            if (viewResult == null)
            {
                throw new ArgumentNullException(nameof(viewResult));
            }

            var viewEngine = viewResult.ViewEngine ?? ViewEngine;
            var viewName   = viewResult.ViewName ?? GetActionName(actionContext);

            var result         = viewEngine.GetView(executingFilePath: null, viewPath: viewName, isMainPage: false);
            var originalResult = result;

            if (!result.Success)
            {
                result = viewEngine.FindView(actionContext, viewName, isMainPage: false);
            }

            if (!result.Success)
            {
                if (originalResult.SearchedLocations.Any())
                {
                    if (result.SearchedLocations.Any())
                    {
                        // Return a new ViewEngineResult listing all searched locations.
                        var locations = new List <string>(originalResult.SearchedLocations);
                        locations.AddRange(result.SearchedLocations);
                        result = ViewEngineResult.NotFound(viewName, locations);
                    }
                    else
                    {
                        // GetView() searched locations but FindView() did not. Use first ViewEngineResult.
                        result = originalResult;
                    }
                }
            }

            if (result.Success)
            {
                if (DiagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.ViewFound"))
                {
                    DiagnosticSource.Write(
                        "Microsoft.AspNetCore.Mvc.ViewFound",
                        new
                    {
                        actionContext = actionContext,
                        isMainPage    = false,
                        result        = viewResult,
                        viewName      = viewName,
                        view          = result.View,
                    });
                }
            }
            else
            {
                if (DiagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.ViewNotFound"))
                {
                    DiagnosticSource.Write(
                        "Microsoft.AspNetCore.Mvc.ViewNotFound",
                        new
                    {
                        actionContext     = actionContext,
                        isMainPage        = false,
                        result            = viewResult,
                        viewName          = viewName,
                        searchedLocations = result.SearchedLocations
                    });
                }
            }

            return(result);
        }
Esempio n. 28
0
#pragma warning restore CS8618

            public override void Execute(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> output, ViewDataDictionary viewData)
            {
                ViewEngineResult viewEngineResult = ViewEngines.Engines.FindPartialView(html.ViewContext, this.ViewName);

                RenderView(html, output, viewData, viewEngineResult);
            }
        public void FindPartialViewLooksAtCacheFirst()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            Mock<IViewEngine> engine = new Mock<IViewEngine>();
            ViewEngineResult engineResult = new ViewEngineResult(new Mock<IView>().Object, engine.Object);
            engine.Setup(e => e.FindPartialView(context, "partial", true)).Returns(engineResult);
            ViewEngineCollection collection = new ViewEngineCollection()
            {
                engine.Object,
            };

            // Act
            ViewEngineResult result = collection.FindPartialView(context, "partial");

            // Assert
            Assert.Same(engineResult, result);
            engine.Verify(e => e.FindPartialView(context, "partial", true), Times.Once());
            engine.Verify(e => e.FindPartialView(context, "partial", false), Times.Never());
        }
        public void FindPartialViewRemovesDuplicateSearchedLocationsFromMultipleEngines() {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            Mock<IViewEngine> engine1 = new Mock<IViewEngine>();
            ViewEngineResult engine1Result = new ViewEngineResult(new[] { "repeatLocation", "location1" });
            engine1.Setup(e => e.FindPartialView(context, "partial", It.IsAny<bool>())).Returns(engine1Result);
            Mock<IViewEngine> engine2 = new Mock<IViewEngine>();
            ViewEngineResult engine2Result = new ViewEngineResult(new[] { "location2", "repeatLocation" });
            engine2.Setup(e => e.FindPartialView(context, "partial", It.IsAny<bool>())).Returns(engine2Result);
            ViewEngineCollection viewEngineCollection = new ViewEngineCollection() {
                engine1.Object,
                engine2.Object,
            };

            // Act
            ViewEngineResult result = viewEngineCollection.FindPartialView(context, "partial");

            // Assert
            var expectedLocations = new[] { "repeatLocation", "location1", "location2" };
            Assert.IsNull(result.View);
            CollectionAssert.AreEquivalent(expectedLocations, result.SearchedLocations.ToList());
        }
        public void FindViewFailureWithOneEngine()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();
            Mock<IViewEngine> engine = new Mock<IViewEngine>();
            ViewEngineResult engineResult = new ViewEngineResult(new[] { "location1", "location2" });
            engine.Setup(e => e.FindView(context, "view", "master", It.IsAny<bool>())).Returns(engineResult);
            collection.Add(engine.Object);

            // Act
            ViewEngineResult result = collection.FindView(context, "view", "master");

            // Assert
            Assert.Null(result.View);
            Assert.Equal(2, result.SearchedLocations.Count());
            Assert.True(result.SearchedLocations.Contains("location1"));
            Assert.True(result.SearchedLocations.Contains("location2"));
        }
Esempio n. 32
0
        private void FindPartialViewAndRender(string partialViewName)
        {
            ViewEngineResult viewEngineResult = _factory.FindPartialView(_actionContext, partialViewName);

            viewEngineResult.View.RenderView(_output);
        }
Esempio n. 33
0
        //protected override bool FileExists(ControllerContext controllerContext, string virtualPath)
        //{
        //    return BuildManager.GetObjectFactory(virtualPath, false) != null;
        //}

        #endregion

        #region Methods

        public override ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
        {
            ViewEngineResult result = FindThemeableView(controllerContext, viewName, masterName, useCache);

            return(result);
        }
Esempio n. 34
0
        private void FindViewAndRender(string viewName, string masterName)
        {
            ViewEngineResult viewEngineResult = _factory.FindView(_actionContext, viewName, masterName);

            viewEngineResult.View.RenderView(_output);
        }
Esempio n. 35
0
 private void OutputDiagnostics(ActionContext actionContext, ViewResult viewResult, string viewName, ValueStopwatch stopwatch, ViewEngineResult result)
 {
     if (result.Success)
     {
         if (DiagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.ViewFound"))
         {
             DiagnosticSource.Write(
                 "Microsoft.AspNetCore.Mvc.ViewFound",
                 new
             {
                 actionContext,
                 isMainPage = true,
                 result     = viewResult,
                 viewName,
                 view = result.View,
             });
         }
     }
     else
     {
         if (DiagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.ViewNotFound"))
         {
             DiagnosticSource.Write(
                 "Microsoft.AspNetCore.Mvc.ViewNotFound",
                 new
             {
                 actionContext,
                 isMainPage = true,
                 result     = viewResult,
                 viewName,
                 searchedLocations = result.SearchedLocations
             });
         }
     }
 }
        public void FindPartialViewReturnsValueFromFirstSuccessfulEngine()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();
            Mock<IViewEngine> engine1 = new Mock<IViewEngine>();
            ViewEngineResult engine1Result = new ViewEngineResult(new Mock<IView>().Object, engine1.Object);
            engine1.Setup(e => e.FindPartialView(context, "partial", It.IsAny<bool>())).Returns(engine1Result);
            Mock<IViewEngine> engine2 = new Mock<IViewEngine>();
            ViewEngineResult engine2Result = new ViewEngineResult(new Mock<IView>().Object, engine2.Object);
            engine2.Setup(e => e.FindPartialView(context, "partial", It.IsAny<bool>())).Returns(engine2Result);
            collection.Add(engine1.Object);
            collection.Add(engine2.Object);

            // Act
            ViewEngineResult result = collection.FindPartialView(context, "partial");

            // Assert
            Assert.Same(engine1Result, result);
        }
Esempio n. 37
0
        /// <summary>
        /// Attempts to find the <see cref="IView"/> associated with <paramref name="viewResult"/>.
        /// </summary>
        /// <param name="actionContext">The <see cref="ActionContext"/> associated with the current request.</param>
        /// <param name="viewResult">The <see cref="ViewResult"/>.</param>
        /// <returns>A <see cref="ViewEngineResult"/>.</returns>
        public virtual ViewEngineResult FindView(ActionContext actionContext, ViewResult viewResult)
        {
            if (actionContext == null)
            {
                throw new ArgumentNullException(nameof(actionContext));
            }

            if (viewResult == null)
            {
                throw new ArgumentNullException(nameof(viewResult));
            }

            var viewEngine = viewResult.ViewEngine ?? ViewEngine;

            var viewName = viewResult.ViewName ?? GetActionName(actionContext);

            var stopwatch = ValueStopwatch.StartNew();

            var result         = viewEngine.GetView(executingFilePath: null, viewPath: viewName, isMainPage: true);
            var originalResult = result;

            if (!result.Success)
            {
                result = viewEngine.FindView(actionContext, viewName, isMainPage: true);
            }

            Logger.ViewResultExecuting(result.ViewName);
            if (!result.Success)
            {
                if (originalResult.SearchedLocations.Any())
                {
                    if (result.SearchedLocations.Any())
                    {
                        // Return a new ViewEngineResult listing all searched locations.
                        var locations = new List <string>(originalResult.SearchedLocations);
                        locations.AddRange(result.SearchedLocations);
                        result = ViewEngineResult.NotFound(viewName, locations);
                    }
                    else
                    {
                        // GetView() searched locations but FindView() did not. Use first ViewEngineResult.
                        result = originalResult;
                    }
                }
            }

            if (DiagnosticSource.IsEnabled())
            {
                OutputDiagnostics(actionContext, viewResult, viewName, stopwatch, result);
            }

            if (result.Success)
            {
                Logger.ViewFound(result.View, stopwatch.GetElapsedTime());
            }
            else
            {
                Logger.ViewNotFound(viewName, result.SearchedLocations);
            }

            return(result);
        }
        public void FindViewLooksAtLocatorIfCacheEmpty()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            Mock<IViewEngine> engine = new Mock<IViewEngine>();
            ViewEngineResult engineResult = new ViewEngineResult(new Mock<IView>().Object, engine.Object);
            engine.Setup(e => e.FindView(context, "view", "master", true)).Returns(new ViewEngineResult(new[] { "path" }));
            engine.Setup(e => e.FindView(context, "view", "master", false)).Returns(engineResult);
            ViewEngineCollection collection = new ViewEngineCollection()
            {
                engine.Object,
            };

            // Act
            ViewEngineResult result = collection.FindView(context, "view", "master");

            // Assert
            Assert.Same(engineResult, result);
            engine.Verify(e => e.FindView(context, "view", "master", true), Times.Once());
            engine.Verify(e => e.FindView(context, "view", "master", false), Times.Once());
        }
Esempio n. 39
0
        /// <summary>
        /// 根据View视图生成静态页面
        /// </summary>
        /// <param name="strStaticPageAbsolutePath">存放静态页面所在绝对路径</param>
        /// <param name="context">ControllerContext</param>
        /// <param name="strViewName">视图名称</param>
        /// <param name="strMasterName">模板视图名称</param>
        /// <param name="model">参数实体模型</param>
        /// <param name="strMessage">返回信息</param>
        /// <param name="isPartial">是否分布视图</param>
        /// <returns>生成成功返回true,失败false</returns>
        public static bool GenerateStaticPage(string strStaticPageAbsolutePath, ControllerContext context, string strViewName, string strMasterName, object model, out string strMessage, bool isPartial = false)
        {
            bool isSuccess = false;

            try
            {
                //创建存放静态页面目录
                if (!Directory.Exists(Path.GetDirectoryName(strStaticPageAbsolutePath)))
                {
                    Directory.CreateDirectory(Path.GetDirectoryName(strStaticPageAbsolutePath));
                }
                //删除已有的静态页面
                //if (File.Exists(strStaticPageAbsolutePath))
                //{
                //    File.Delete(strStaticPageAbsolutePath);
                //}

                ViewEngineResult result = null;
                if (isPartial)
                {
                    result = ViewEngines.Engines.FindPartialView(context, strViewName);
                }
                else
                {
                    result = ViewEngines.Engines.FindView(context, strViewName, strMasterName);
                }
                if (model != null)
                {
                    context.Controller.ViewData.Model = model;
                    //context.Controller.ViewBag.Ads = model;
                }
                //设置临时数据字典作为静态化标识,可以在视图上使用TempData["IsStatic"]来控制某些元素显示。
                if (!context.Controller.TempData.ContainsKey("IsStatic"))
                {
                    context.Controller.TempData.Add("IsStatic", true);
                }
                if (result.View != null)
                {
                    using (var sw = new StringWriter())
                    {
                        string strResultHtml = string.Empty;
                        //填充数据模型到视图中,并获取完整的页面
                        ViewContext viewContext = new ViewContext(context, result.View, context.Controller.ViewData, context.Controller.TempData, sw);
                        result.View.Render(viewContext, sw);
                        strResultHtml = sw.ToString();
                        //通过IO操作将页面内容生成静态页面
                        File.WriteAllText(strStaticPageAbsolutePath, strResultHtml);
                        //strMessage = string.Format("生成静态页面成功!存放路径:{0}", strStaticPageAbsolutePath);
                        strMessage = "生成静态页面成功";
                        isSuccess  = true;
                    }
                }
                else
                {
                    isSuccess  = false;
                    strMessage = "生成静态页面失败,未找到视图";
                }
            }
            catch (IOException ex)
            {
                strMessage = ex.Message;
                isSuccess  = false;
            }
            catch (Exception ex)
            {
                strMessage = ex.Message;
                isSuccess  = false;
            }
            return(isSuccess);
        }
        public void FindViewRemovesDuplicateSearchedLocationsFromMultipleEngines()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            Mock<IViewEngine> engine1 = new Mock<IViewEngine>();
            ViewEngineResult engine1Result = new ViewEngineResult(new[] { "repeatLocation", "location1" });
            engine1.Setup(e => e.FindView(context, "view", "master", It.IsAny<bool>())).Returns(engine1Result);
            Mock<IViewEngine> engine2 = new Mock<IViewEngine>();
            ViewEngineResult engine2Result = new ViewEngineResult(new[] { "location2", "repeatLocation" });
            engine2.Setup(e => e.FindView(context, "view", "master", It.IsAny<bool>())).Returns(engine2Result);
            ViewEngineCollection collection = new ViewEngineCollection()
            {
                engine1.Object,
                engine2.Object,
            };

            // Act
            ViewEngineResult result = collection.FindView(context, "view", "master");

            // Assert
            Assert.Null(result.View);
            var expectedLocations = new[] { "repeatLocation", "location1", "location2" };
            Assert.Equal(expectedLocations, result.SearchedLocations.ToArray());
        }
Esempio n. 41
0
    /// <summary>
    /// Determines if the provided view exists for the this controller
    /// </summary>
    /// <param name="view">The name of the view</param>
    /// <returns></returns>
    public static bool ViewExists(this Controller controller, string view)
    {
        ViewEngineResult result = ViewEngines.Engines.FindView(controller.ControllerContext, view, null);

        return(result.View != null);
    }
        public void FindPartialViewDelegatesToResolver()
        {
            // Arrange
            Mock<IView> view = new Mock<IView>();
            ControllerContext context = new ControllerContext();
            Mock<IViewEngine> locatedEngine = new Mock<IViewEngine>();
            ViewEngineResult engineResult = new ViewEngineResult(view.Object, locatedEngine.Object);
            locatedEngine.Setup(e => e.FindPartialView(context, "ViewName", true))
                .Returns(engineResult);
            Mock<IViewEngine> secondEngine = new Mock<IViewEngine>();

            var resolver = new Mock<IDependencyResolver>();
            resolver.Setup(r => r.GetServices(typeof(IViewEngine))).Returns(new IViewEngine[] { locatedEngine.Object, secondEngine.Object });

            ViewEngineCollection engines = new ViewEngineCollection(new IViewEngine[0], resolver.Object);

            // Act
            ViewEngineResult result = engines.FindPartialView(context, "ViewName");

            // Assert
            Assert.Same(engineResult, result);
            secondEngine.Verify(e => e.FindPartialView(context, "ViewName", It.IsAny<bool>()), Times.Never());
        }
Esempio n. 43
0
        /// <summary>
        /// Gets requested Kendo grid
        /// GET: Events/GetGrid/
        /// </summary>
        public ActionResult GetGrid(string gridType)
        {
            PartialViewResult view;
            string            viewName;
            JsonResult        customGridData;

            switch (gridType)
            {
            case "Summary":
                viewName       = "_SummaryGrid";
                customGridData = GetGridData(CurrentCity.Id, CurrentController, "GetSummaryEvents");
                break;

            case "Functional Status":
                viewName       = "_DiagnosticsGrid";
                customGridData = GetGridData(CurrentCity.Id, CurrentController, "GetDiagnosticEvents");
                break;

            case "Alarms":
                viewName       = "_AlarmsGrid";
                customGridData = GetGridData(CurrentCity.Id, CurrentController, "GetAlarmEvents");
                break;

            case "Connections":
                viewName       = "_ConnectionsGrid";
                customGridData = GetGridData(CurrentCity.Id, CurrentController, "GetConnectionEvents");
                break;

            case "Transactions":
                viewName       = "_TransactionsGrid";
                customGridData = GetGridData(CurrentCity.Id, CurrentController, "GetTransactionEvents");
                break;

            case "Collection Comm":
                viewName       = "_CollectionCommGrid";
                customGridData = GetGridData(CurrentCity.Id, CurrentController, "GetCollectionCommEvents");
                break;

            case "Collection CBR":
                viewName       = "_CollectionCBRGrid";
                customGridData = GetGridData(CurrentCity.Id, CurrentController, "GetCollectionCBREvents");
                break;

            default:
                return(null);
            }

            // Get the partial view and render the html to a string
            string html = string.Empty;

            using (StringWriter sw = new StringWriter())
            {
                ViewEngineResult viewResult  = ViewEngines.Engines.FindPartialView(ControllerContext, viewName);
                ViewContext      viewContext = new ViewContext(ControllerContext, viewResult.View, ViewData, TempData, sw);
                viewResult.View.Render(viewContext, sw);

                html = sw.GetStringBuilder().ToString();
            }

            // Concatenate the data into an anonymous typed object
            var data = new
            {
                view = html,
                customGridData
            };

            // return as JSON
            return(Json(data, JsonRequestBehavior.AllowGet));
        }