public override void Close()
{
// Checking if the stream was already closed
if (!_ms.CanSeek)
{
return;
}
_ms.Seek(0, System.IO.SeekOrigin.Begin);
var bytes = _ms.ToArray();
string html = Encoding.UTF8.GetString(bytes);
string newHtml = PageUrlHelper.ChangeRenderingPageUrlsToPublic(html);
if (html != newHtml)
{
bytes = Encoding.UTF8.GetBytes(newHtml);
}
_innerStream.Write(bytes, 0, bytes.Length);
_innerStream.Close();
_ms.Close();
}
public void ProcessRequest(HttpContext context)
{
var functionName = (string)context.Request.RequestContext.RouteData.Values["function"];
var dataCulture = GetCurrentDataCulture(context);
using (var data = new DataConnection())
{
if (!data.Get <IFunctionRoute>().Any())
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
}
IFunction function;
if (!FunctionFacade.TryGetFunction(out function, functionName))
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
using (var dataScope = new DataScope(DataScopeIdentifier.Public, dataCulture))
{
var functionResult = FunctionFacade.Execute <object>(function, context.Request.QueryString);
if (functionResult == null)
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
var xhtmlDocument = functionResult as XhtmlDocument;
if (xhtmlDocument != null)
{
PageRenderer.ExecuteEmbeddedFunctions(xhtmlDocument.Root, new FunctionContextContainer());
PageRenderer.NormalizeXhtmlDocument(xhtmlDocument);
var xhtml = xhtmlDocument.ToString();
xhtml = PageUrlHelper.ChangeRenderingPageUrlsToPublic(functionResult.ToString());
xhtml = MediaUrlHelper.ChangeInternalMediaUrlsToPublic(xhtml);
context.Response.Write(xhtml);
}
else
{
context.Response.Write(functionResult.ToString());
if (functionResult is XNode && function.ReturnType != typeof(XhtmlDocument))
{
context.Response.ContentType = "text/xml";
}
}
}
}
protected override void Render(HtmlTextWriter writer)
{
var markupBuilder = new StringBuilder();
using (var sw = new StringWriter(markupBuilder))
{
base.Render(new HtmlTextWriter(sw));
}
string xhtml = markupBuilder.ToString();
using (Profiler.Measure("Changing 'internal' page urls to 'public'"))
{
xhtml = PageUrlHelper.ChangeRenderingPageUrlsToPublic(xhtml);
}
using (Profiler.Measure("Changing 'internal' media urls to 'public'"))
{
xhtml = MediaUrlHelper.ChangeInternalMediaUrlsToPublic(xhtml);
}
writer.Write(xhtml);
}
public override void ExecuteResult(ControllerContext context)
{
string markup;
using (TimerProfilerFacade.CreateTimerProfiler())
{
var page = PageRenderer.CurrentPage;
var markupBuilder = new StringBuilder();
var sw = new StringWriter(markupBuilder);
var output = new HtmlTextWriter(sw);
IView view;
using (Profiler.Measure("Resolving view for template"))
{
view = FindView(context).View;
}
var viewContext = new ViewContext(context, view, ViewData, TempData, output);
view.Render(viewContext, output);
markup = markupBuilder.ToString();
var xml = XDocument.Parse(markup);
var functionContext = PageRenderer.GetPageRenderFunctionContextContainer();
functionContext = new FunctionContextContainer(functionContext, new Dictionary <string, object>
{
{ "viewContext", viewContext }
});
using (Profiler.Measure("Executing embedded functions"))
{
PageRenderer.ExecuteEmbeddedFunctions(xml.Root, functionContext);
}
using (Profiler.Measure("Resolving pagefields"))
{
PageRenderer.ResolvePageFields(xml, page);
}
var document = new XhtmlDocument(xml);
using (Profiler.Measure("Normalizing html"))
{
PageRenderer.NormalizeXhtmlDocument(document);
}
PageRenderer.ResolveRelativePaths(document);
PageRenderer.AppendC1MetaTags(page, document);
using (Profiler.Measure("Resolving localized strings"))
{
LocalizationParser.Parse(document);
}
markup = document.ToString();
using (Profiler.Measure("Changing 'internal' page urls to 'public'"))
{
markup = PageUrlHelper.ChangeRenderingPageUrlsToPublic(markup);
}
using (Profiler.Measure("Changing 'internal' media urls to 'public'"))
{
markup = MediaUrlHelper.ChangeInternalMediaUrlsToPublic(markup);
}
markup = _mvcContext.FormatXhtml(markup);
}
if (_mvcContext.ProfilingEnabled)
{
markup = _mvcContext.BuildProfilerReport();
context.HttpContext.Response.ContentType = "text/xml";
}
context.HttpContext.Response.Write(markup);
}
void context_BeginRequest(object sender, EventArgs e)
{
const string cacheKey = "LegacyUrlHandler";
var application = (HttpApplication)sender;
var context = application.Context;
var request = context.Request;
var requestPath = request.Path;
var requestPathInfo = "";
int pathInfoTokenIndex = requestPath.IndexOf(PathInfoToken);
if (pathInfoTokenIndex > -1)
{
requestPathInfo = requestPath.Substring(pathInfoTokenIndex + _pathInfoTokenLength - 1);
requestPath = requestPath.Substring(0, pathInfoTokenIndex + _pathInfoTokenLength - 1);
}
//LoggingService.LogInformation("Legacy URL in:", string.Format("{0} - {1}", requestPath, requestPathInfo));
LegacyUrlHandlerFacade.UrlMappings legacyUrlMappings;
if (!Cache.Get(cacheKey, out legacyUrlMappings))
{
legacyUrlMappings = LegacyUrlHandlerFacade.GetMappingsFromXml();
Cache.Add(cacheKey, legacyUrlMappings, LegacyUrlHandlerFacade.XmlFileName);
}
string mappingPath = legacyUrlMappings.GetMappedUrl(request.Url.Host, requestPath);
if (mappingPath == null)
{
return;
}
if (PageUrlHelper.IsInternalUrl(mappingPath) || PageUrlHelper.IsPublicUrl(mappingPath))
{
var pageUrlOptions = PageUrls.ParseUrl(mappingPath);
if (pageUrlOptions != null)
{
var publicUrl = PageUrls.BuildUrl(pageUrlOptions, UrlKind.Public, new UrlSpace());
if (publicUrl != requestPath)
{
if (!string.IsNullOrEmpty(requestPathInfo))
{
publicUrl = string.Format("{0}{1}", publicUrl, requestPathInfo);
}
var queryString = context.Request.QueryString;
if (queryString.Count > 0)
{
publicUrl = string.Format("{0}{1}?{2}", publicUrl, requestPathInfo, queryString);
}
context.Response.RedirectPermanent(publicUrl, true);
}
}
}
else
{
context.Response.RedirectPermanent(mappingPath, true);
}
}
