public void Render(ViewContext viewContext, TextWriter writer)
{
var template = (WebViewPage)MockVirtualPathFactory.InternalCreateInstance(_path);
template.VirtualPath = _virtualPath;
template.ViewContext = viewContext;
template.ViewData = viewContext.ViewData;
WebPageRenderingBase currentPage = template;
var pageDirectory = Path.GetDirectoryName(_path);
if (_runViewStartPage)
{
while (!String.IsNullOrEmpty(pageDirectory) && pageDirectory != "/" && MockVirtualPathFactory.ViewPathContains(pageDirectory))
{
foreach (var extension in _viewStartFileExtensions)
{
var path = Path.Combine(pageDirectory, "_ViewStart" + "." + extension);
if (MockVirtualPathFactory.InternalExists(path))
{
var parentStartPage = (StartPage)MockVirtualPathFactory.InternalCreateInstance(path);
parentStartPage.VirtualPath = path;
parentStartPage.ChildPage = currentPage;
currentPage = parentStartPage;
break;
}
}
pageDirectory = Path.GetDirectoryName(pageDirectory);
}
}
template.InitHelpers();
template.ExecutePageHierarchy(new WebPageContext(viewContext.HttpContext, page: null, model: null), writer, currentPage); // , currentPage);
}
public void Render(ViewContext viewContext, TextWriter writer)
{
WebViewPage webViewPage = _viewPageActivator.Create(viewContext.Controller.ControllerContext, _type) as WebViewPage;
if (webViewPage == null)
{
throw new InvalidOperationException("Invalid view type");
}
if (!String.IsNullOrEmpty(_masterPath))
{
_overriddenLayoutSetter.Value(webViewPage, _masterPath);
}
webViewPage.VirtualPath = _virtualPath;
webViewPage.ViewContext = viewContext;
webViewPage.ViewData = viewContext.ViewData;
webViewPage.InitHelpers();
WebPageRenderingBase startPage = null;
if (this.RunViewStartPages)
{
startPage = StartPage.GetStartPage(webViewPage, "_ViewStart", ViewStartFileExtensions);
}
var pageContext = new WebPageContext(viewContext.HttpContext, webViewPage, null);
webViewPage.ExecutePageHierarchy(pageContext, writer, startPage);
}
public void Render(ViewContext viewContext, TextWriter writer)
{
var webViewPage = viewPageActivator.Create(viewContext.Controller.ControllerContext, type) as WebViewPage;
if (webViewPage == null)
{
throw new InvalidOperationException("Invalid view type");
}
webViewPage.VirtualPath = virtualPath;
webViewPage.ViewContext = viewContext;
webViewPage.ViewData = viewContext.ViewData;
webViewPage.InitHelpers();
webViewPage.VirtualPathFactory = virtualPathFactory;
WebPageRenderingBase startPage = null;
if (this.RunViewStartPages)
{
startPage = StartPageHelper.GetStartPage(webViewPage, "_ViewStart", ViewStartFileExtensions);
}
var pageContext = new WebPageContext(viewContext.HttpContext, webViewPage, startPage);
webViewPage.ExecutePageHierarchy(pageContext, writer, startPage);
}
protected override void RenderView(ViewContext viewContext, TextWriter writer, object instance)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
WebViewPage webViewPage = instance as WebViewPage;
if (webViewPage == null)
{
throw new InvalidOperationException(
String.Format(
CultureInfo.CurrentCulture,
MvcResources.CshtmlView_WrongViewBase,
ViewPath));
}
// An overriden master layout might have been specified when the ViewActionResult got returned.
// We need to hold on to it so that we can set it on the inner page once it has executed.
webViewPage.OverridenLayoutPath = LayoutPath;
webViewPage.VirtualPath = ViewPath;
webViewPage.ViewContext = viewContext;
webViewPage.ViewData = viewContext.ViewData;
webViewPage.InitHelpers();
WebPageRenderingBase startPage = null;
if (RunViewStartPages)
{
startPage = StartPageLookup(webViewPage, RazorViewEngine.ViewStartFileName, ViewStartFileExtensions);
}
webViewPage.ExecutePageHierarchy(new WebPageContext(context: viewContext.HttpContext, page: null, model: null), writer, startPage);
}
public void Render(ViewContext viewContext, TextWriter writer)
{
WebViewPage webViewPage = new PrecompiledPageActivator().Create(viewContext.Controller.ControllerContext, ViewType) as WebViewPage;
if (webViewPage == null)
{
throw new InvalidOperationException("Invalid view type");
}
webViewPage.Layout = LayoutPath;
webViewPage.VirtualPath = VirtualPath;
webViewPage.ViewContext = viewContext;
webViewPage.ViewData = viewContext.ViewData;
webViewPage.InitHelpers();
WebPageRenderingBase startPage = null;
if (!this.PartialView)
{
startPage = StartPage.GetStartPage(webViewPage, "_ViewStart", _viewsExtension);
}
var pageContext = new WebPageContext(viewContext.HttpContext, webViewPage, null);
webViewPage.ExecutePageHierarchy(pageContext, writer, startPage);
}
/// <summary>
/// immutable constructor
/// </summary>
/// <param name="previous"></param>
/// <param name="query"></param>
private ExtJsReader(ExtJsReader <TContext, TEntity> previous, IQueryable <TEntity> query)
{
_query = query;
_page = previous._page;
_orderByExpression = previous._orderByExpression;
previous._filters.ForEach(x => _filters.Add(x.Key, x.Value));
previous._sorters.ForEach(x => _sorters.Add(x.Key, x.Value));
}
/// <summary>
/// Retrieves the user from the session(can be used from the view)
/// </summary>
/// <param name="page"></param>
/// <returns>The user from the session or null if not found</returns>
public static IPrincipal GetUser(this WebPageRenderingBase page)
{
// Make sure there is a user available
if (page.IsLoggedIn())
{
// Get the user from the principal
return(page.Session["principal"] as IPrincipal);
}
return(null);
}
void IView.Render(ViewContext viewContext, System.IO.TextWriter writer)
{
webViewPage.VirtualPath = virtualPath;
webViewPage.ViewContext = viewContext;
webViewPage.ViewData = viewContext.ViewData;
WebPageRenderingBase startPage = StartPage.GetStartPage(webViewPage, "_ViewStart", FileExtensions);
webViewPage.ExecutePageHierarchy(new WebPageContext(context: viewContext.HttpContext, page: null, model: null), writer, startPage);
}
public ExtJsDeleter(WebPageRenderingBase page, bool findFirst = false, string keyProperty = "Id")
: base(page)
{
_findFirst = findFirst;
if (findFirst)
{
var pi = typeof(TEntity).GetProperty(keyProperty);
_id = pi;
}
}
public static void SetLayout(WebPageRenderingBase page)
{
if (IsNavigationEnabled(page.Context))
{
page.Layout = "~/Views/Shared/_LayoutNavigation.cshtml";
}
else
{
page.Layout = "~/Views/Shared/_Layout.cshtml";
}
}
private WebPageRenderingBase GetStartPage(WebViewPage webViewPage)
{
WebPageRenderingBase startPage = null;
if (RunViewStartPages)
{
startPage = StartPageLookup(webViewPage, RazorViewEngine.ViewStartFileName, ViewStartFileExtensions);
}
return(startPage);
}
/// <summary>
/// 呈现View
/// </summary>
/// <param name="viewContext"></param>
/// <param name="writer"></param>
/// <param name="instance"></param>
protected override void RenderView(ViewContext viewContext, TextWriter writer, object instance)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
ThemedWebViewPage webViewPage = instance as ThemedWebViewPage;
if (webViewPage == null)
{
throw new InvalidOperationException(
String.Format(
CultureInfo.CurrentCulture, "The view at '{0}' must derive from WebViewPage, or WebViewPage<TModel>.",
ViewPath));
}
webViewPage.VirtualPath = ViewPath;
webViewPage.ViewContext = viewContext;
webViewPage.ViewData = viewContext.ViewData;
webViewPage.ApplicationKey = ApplicationKey;
webViewPage.InitHelpers();
WebPageRenderingBase startPage = null;
// 在View中设置的Layout也可以依据视图引擎进行定位
if (!IsPartialView)
{
if (!string.IsNullOrEmpty(OverridenLayoutPath))
{
webViewPage.OverridenLayoutPath = OverridenLayoutPath;
}
else
{
webViewPage.IsPartialView = false;
webViewPage.ThemeAppearance = ThemeAppearance;
webViewPage.FindLayoutPathOfThemeDelegate = FindLayoutPathOfThemeDelegate;
}
}
else
{
webViewPage.IsPartialView = true;
}
//禁用ViewStartPage
//if (RunViewStartPages)
//{
// startPage = StartPageLookup(webViewPage, RazorViewEngine.ViewStartFileName, ViewStartFileExtensions);
//}
webViewPage.ExecutePageHierarchy(new WebPageContext(context: viewContext.HttpContext, page: null, model: null), writer, startPage);
}
/// <summary>
/// Walks the page hierarcy to find the requested page.
/// </summary>
private static WebPageRenderingBase GetRootPage(StartPage page)
{
WebPageRenderingBase currentPage = null;
while (page != null)
{
currentPage = page.ChildPage;
page = currentPage as StartPage;
}
Debug.Assert(currentPage != null, "Should never be null");
return(currentPage);
}
public void Render(ViewContext viewContext, TextWriter writer)
{
Type viewType = BuildManager.GetCompiledType(this.ViewPath);
object instance = Activator.CreateInstance(viewType);
WebViewPage page = (WebViewPage)instance as WebViewPage;
page.VirtualPath = this.ViewPath;
page.ViewContext = viewContext;
page.ViewData = viewContext.ViewData;
page.InitHelpers();
WebPageContext pageContext = new WebPageContext(viewContext.HttpContext, null, null);
WebPageRenderingBase startPage = StartPage.GetStartPage(page, StartPageFile, new string[] { "cshtml", "vbhtml" });
page.ExecutePageHierarchy(pageContext, writer, startPage);
}
public PageViewModel(WebPageRenderingBase page)
{
if (page.Request.IsAuthenticated)
{
var identity = page.User.Identity as System.Security.Claims.ClaimsIdentity;
if (identity != null)
{
if (page.Request.IsSecureConnection)
{
UserName = identity.GetUserName();
}
UserId = Convert.ToInt32(identity.GetUserId());
DisplayName = identity.FindFirstValue(AppClaimTypes.DisplayName) ?? UserName;
IsTeacher = identity.HasClaim(i => i.Type == AppClaimTypes.IsTeacher);
}
}
}
/// <summary>
/// Returns either the root-most init page, or the provided page itself if no init page is found
/// </summary>
public static WebPageRenderingBase GetStartPage(WebPageRenderingBase page, string fileName, IEnumerable <string> supportedExtensions)
{
if (page == null)
{
throw new ArgumentNullException("page");
}
if (String.IsNullOrEmpty(fileName))
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, "Cannot be null or empty", "fileName"), "fileName");
}
if (supportedExtensions == null)
{
throw new ArgumentNullException("supportedExtensions");
}
// Use the page's VirtualPathFactory if available
return(GetStartPage(page, page.VirtualPathFactory, HttpRuntime.AppDomainAppVirtualPath, fileName, supportedExtensions));
}
public void Render(ViewContext viewContext, System.IO.TextWriter writer)
{
if (string.IsNullOrEmpty(template))
{
template = "default";
}
string viewPath = "~/Views/" + template + "/" + viewContext.RouteData.GetRequiredString("controller") + "/" + viewContext.RouteData.GetRequiredString("action") + ".cshtml";
Type viewType = BuildManager.GetCompiledType(viewPath);
WebViewPage page = Activator.CreateInstance(viewType) as WebViewPage;
page.Layout = layout;
page.VirtualPath = viewPath;
page.ViewContext = viewContext;
page.ViewData = viewContext.ViewData;
page.InitHelpers();
WebPageContext pageContext = new WebPageContext(viewContext.HttpContext, null, null);
WebPageRenderingBase startPage = StartPage.GetStartPage(page, "_ViewStart", new string[] { "cshtml", "vbhtml" });
page.ExecutePageHierarchy(pageContext, writer, startPage);
}
public static FileVersionInfo GetApplicationVersion(this WebPageRenderingBase webViewPage)
{
var version = webViewPage.Session != null
? webViewPage.Context.Application["Version"] as FileVersionInfo
: null;
if (version == null)
{
var executingAssembly = GetWebEntryAssembly();
version = FileVersionInfo.GetVersionInfo(executingAssembly.Location);
if (webViewPage.Session != null)
{
webViewPage.Context.Application.Lock();
webViewPage.Context.Application["Version"] = version;
webViewPage.Context.Application.UnLock();
}
}
return(version);
}
internal static WebPageRenderingBase GetStartPage(WebPageRenderingBase page, IVirtualPathFactory virtualPathFactory, string appDomainAppVirtualPath,
string fileName, IEnumerable <string> supportedExtensions)
{
// Build up a list of pages to execute, such as one of the following:
// ~/somepage.cshtml
// ~/_pageStart.cshtml --> ~/somepage.cshtml
// ~/_pageStart.cshtml --> ~/sub/_pageStart.cshtml --> ~/sub/somepage.cshtml
WebPageRenderingBase currentPage = page;
var pageDirectory = VirtualPathUtility.GetDirectory(page.VirtualPath);
// Start with the requested page's directory, find the init page,
// and then traverse up the hierarchy to find init pages all the
// way up to the root of the app.
while (!string.IsNullOrEmpty(pageDirectory))
{
// Go through the list of supported extensions
foreach (var extension in supportedExtensions)
{
var virtualPath = VirtualPathUtility.Combine(pageDirectory, fileName + "." + extension);
// Can we build a file from the current path?
if (virtualPathFactory.Exists(virtualPath))
{
var parentStartPage = virtualPathFactory.CreateInstance(virtualPath) as StartPage;
parentStartPage.VirtualPath = virtualPath;
parentStartPage.ChildPage = currentPage;
parentStartPage.VirtualPathFactory = virtualPathFactory;
currentPage = parentStartPage;
break;
}
}
pageDirectory = pageDirectory == "~/"
? null
: VirtualPathUtility.GetDirectory(pageDirectory);
}
// At this point 'currentPage' is the root-most StartPage (if there were
// any StartPages at all) or it is the requested page itself.
return(currentPage);
}
public void Render(ViewContext viewContext, TextWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (page == null)
{
throw new InvalidOperationException("Cannot create a page from " + viewPath);
}
//damn, now why is this internal, how can you ever reuse the webviewpage then??
//page.OverridenLayoutPath = this.LayoutPath;
if (!String.IsNullOrEmpty(this.LayoutPath))
{
page.Layout = LayoutPath;
}
page.VirtualPath = viewPath;
page.ViewContext = viewContext;
page.ViewData = viewContext.ViewData;
page.InitHelpers();
WebPageRenderingBase startPage = null;
if (this.RunViewStartPages)
{
startPage = this.StartPageLookup(page, VirtualPathFactoryManagerViewEngine.ViewStartFileName, this.ViewStartFileExtensions);
}
var httpContext = viewContext.HttpContext;
WebPageRenderingBase base4 = null;
object model = null;
//instead of page.OverridenLayoutPath:
if (!String.IsNullOrEmpty(this.LayoutPath))
{
page.Layout = LayoutPath;
}
page.ExecutePageHierarchy(new WebPageContext(httpContext, base4, model), writer, startPage);
}
protected void RenderView(ViewContext viewContext, TextWriter writer, object instance)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
WebViewPage page = instance as WebViewPage;
if (page == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Wrong view base - {0}", new object[] { ViewPath }));
}
// page.OverridenLayoutPath = "";// this.LayoutPath;
page.VirtualPath = ViewPath;
page.ViewContext = viewContext;
page.ViewData = viewContext.ViewData;
page.InitHelpers();
HttpContextBase httpContext = viewContext.HttpContext;
WebPageRenderingBase base4 = null;
object model = null;
((ICompiledViewPage)page).ExecutePage(new WebPageContext(httpContext, base4, model), writer);
}
public ExtJsCreator(WebPageRenderingBase page)
: base(page)
{
}
public static ICurrentUser CurrentUser(this WebPageRenderingBase webPageRendering)
{
var currentUser = IocContainer.GetContainer().Get <PointEx.Web.Infrastructure.ICurrentUser>();
return(currentUser);
}
public ExtJsReader(WebPageRenderingBase page, Func <IQueryable <TEntity>, IQueryable <TEntity> > orderByExpression)
{
_page = page;
_query = Context.Set <TEntity>();
_orderByExpression = orderByExpression;
}
//Re: $(window).unload(... Session.Exit ...);
//Session.Exit does not work well when the page navigated to is retrieved from browser cache (Back, Favorites, etc)
//It returns success and removes cookie, but new session is not created for the new page as its code behind does not execute
public static bool Exists(WebPageRenderingBase page, bool app, out bool newSession)
{
var sessionToken = Guid.Empty;
var sessionRequirement = app || (global::Settings.Instance.Session.Handling & global::Model.Session.HandlingType.Strict) > 0 || page.Page.SessionRequired != null ? SessionRequirement.Required : SessionRequirement.None;
if (page.Page.SessionRequiredNew != null)
{
sessionRequirement = SessionRequirement.RequiredNew;
}
//http://en.wikipedia.org/wiki/HTTP_cookie
//A session cookie only lasts for the duration of users using the website.
//A web browser normally deletes session cookies when it quits.
//A session cookie is created when no Expires directive is provided when the cookie is created.
//Browsers instances will share session cookie http://blogs.msdn.com/b/ie/archive/2009/05/06/session-cookies-sessionstorage-and-ie8.aspx
var initCookie = page.Request.Cookies[global::Settings.Instance.Session.InitCookieName];
var handoffCookie = page.Request.Cookies[global::Settings.Instance.Session.HandoffCookieName];
//Trying to create a new session on browser refresh http://stackoverflow.com/questions/385367/what-requests-do-browsers-f5-and-ctrl-f5-refreshes-generate
//Will only work for Ctrl-F5 or Shift-F5 (FF) requests but not plain Refresh/F5 unfortunately
//Easier solution could be to check somehow if Refresh or X button was clicked and not set session cookie in window.onbeforeunload
var resetSession = page.Request.Headers["Pragma"] == "no-cache" || page.Request.Headers["Cache-Control"] == "no-cache";
string domain = page.Request.Url.DnsSafeHost != "localhost" ? String.Format(".{0}", page.Request.Url.DnsSafeHost) : null;
//Client will try to enter session under following conditions
//1. Session.HandlingType.Strict mode is on
//2. Page.SessionRequired or Page.SessionRequiredNew is set
//3. HandoffCookie with Token is present
//Handoff cookie exists - check if can keep it
if (handoffCookie != null)
{
var sessionHandoff = new global::Model.Session.Handoff(handoffCookie.Value);
//Session exists - check if can keep it
if (Guid.TryParse(sessionHandoff.Token, out sessionToken) && sessionToken != Guid.Empty)
{
if (!(sessionRequirement == SessionRequirement.RequiredNew || resetSession))
{
//Validate may create new session (if required) and return its token
var token = global::Foundation.Session.Manager.Validate(sessionToken, sessionHandoff.User.Id, sessionRequirement != SessionRequirement.None, page.Request.UserHostAddress);
if (token != Guid.Empty && token != sessionToken) //Validate created new session - handoffCookie must be deleted (below)
{
sessionToken = token;
resetSession = true;
}
else if (token == Guid.Empty) //Session is not valid anymore and not required - handoffCookie must be deleted (below)
{
sessionToken = Guid.Empty;
resetSession = true;
}
//else //Session is valid - don't need to do anything
}
else //New session is required or page is refreshed
{
sessionToken = Guid.Empty;
}
}
//Handoff cookie is key to session handling and may not stick around
//New session, page is refresh, session not valid anymore and not required
if (sessionRequirement == SessionRequirement.RequiredNew || resetSession)
{
//Cookies.Remove method does not seem to delete the cookie
if (domain != null)
{
handoffCookie.Domain = domain;
}
handoffCookie.Expires = DateTime.Now.AddDays(-1);
page.Response.Cookies.Set(handoffCookie);
handoffCookie = null;
}
}
if (sessionRequirement != SessionRequirement.None)
{
if (sessionToken == Guid.Empty) //Validate may have returned new token already
{
sessionToken = global::Foundation.Session.Manager.Create(page.Request.UserHostAddress);
}
//Foundation.Event.Log.Enqueue(new global::Foundation.Event.Record(global::Settings.LogEventType.Trace, "WebPageBase.SessionExists", String.Format("New session: {0}", sessionToken)));
if (initCookie == null || !initCookie.HttpOnly || initCookie.Expires != DateTime.MinValue)
{
initCookie = new HttpCookie(global::Settings.Instance.Session.InitCookieName);
initCookie.Value = sessionToken.ToString("N");
initCookie.HttpOnly = true;
initCookie.Path = "/";
if (domain != null)
{
initCookie.Domain = domain;
}
//cookie.Expires = DateTime.UtcNow.AddSeconds(global::Settings.Instance.Session.CookieTimeout);
page.Response.Cookies.Add(initCookie);
}
else
{
initCookie.Value = sessionToken.ToString("N");
initCookie.HttpOnly = true;
initCookie.Path = "/";
if (domain != null)
{
initCookie.Domain = domain;
}
//cookie.Expires = DateTime.UtcNow.AddSeconds(global::Settings.Instance.Session.CookieTimeout);
page.Response.Cookies.Set(initCookie);
}
}
else if (initCookie != null) //Delete initCookie if present
{
//Cookies.Remove method does not seem to delete the cookie
if (domain != null)
{
initCookie.Domain = domain;
}
initCookie.Expires = DateTime.Now.AddDays(-1);
page.Response.Cookies.Set(initCookie);
}
newSession = sessionRequirement == SessionRequirement.RequiredNew || resetSession;
return(sessionToken != Guid.Empty);
}
/// <summary>
/// Determines if the specified virtualPath is being requested. We do this by walking the page hierarchy
/// and comparing the virtualPath with the child page's VirtualPath property (which in the case of ApplicationParts are compiled into the assembly
/// using the PageVirtualPath attribute).
/// </summary>
internal static bool IsRequestingPage(this StartPage page, string virtualPath)
{
WebPageRenderingBase webPage = GetRootPage(page);
return(webPage.VirtualPath.Equals(virtualPath, StringComparison.OrdinalIgnoreCase));
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="html"></param>
public UIHelper(WebPageRenderingBase parent, HtmlHelper html)
{
Parent = parent;
Html = html;
}
private WebPageBase CreatePage(ViewContext viewContext, System.IO.TextWriter writer, out WebPageContext pageContext, out WebPageRenderingBase startPage)
{
var basePage = (WebPageBase)Activator.CreateInstance(Compiled);
basePage.VirtualPath = Path;
basePage.VirtualPathFactory = new PrecompiledVirtualPathFactory(CompiledTypeLookup, basePage.VirtualPathFactory);
pageContext = new WebPageContext(viewContext.HttpContext, basePage, null);
startPage = RunViewStart
? StartPage.GetStartPage(basePage, "_ViewStart", ViewEngine.FileExtensions)
: null;
var viewPage = basePage as WebViewPage;
if (viewPage != null)
{
if (!string.IsNullOrEmpty(MasterPath))
{
LayoutSetter(viewPage, MasterPath);
}
viewPage.ViewContext = viewContext;
viewPage.ViewData = viewContext.ViewData;
viewPage.InitHelpers();
}
return(basePage);
}
protected ExtJsCrudBase(WebPageRenderingBase page)
{
Page = page;
Entity = GetEntity();
}
/// <summary>
/// 判断是否是微信内置浏览器。
/// </summary>
/// <param name="page">Web页面视图。</param>
/// <returns>返回是与否。</returns>
public static bool IsWechatBrowser(this WebPageRenderingBase page)
{
return(page.Request.UserAgent.ToLower().Contains("micromessenger"));
}
