My.Web.UrlRewriteModule

using EPiServer;
using EPiServer.BaseLibrary;
using EPiServer.Core;
using EPiServer.Globalization;
using EPiServer.Web.Routing;
using log4net;
using System;
using System.Globalization;
using System.IO;
using System.Web;
using System.Web.Routing;
using System.Web.UI;

namespace My.Web
{
    /// <summary>
    /// Implements UrlSegment-based URL rewriting.
    ///
    /// </summary>
    ///
    /// <remarks>
    /// Refer to "Routing" in the Developer Guide for more information and examples.
    ///
    /// </remarks>
    public class UrlRewriteModule : UrlRewriteModuleBase
    {
        /// <summary>
        /// A logger instance.
        ///
        /// </summary>
        private static ILog _log = LogManager.GetLogger(typeof(UrlRewriteModule));

        static UrlRewriteModule()
        {
        }

        /// <summary>
        /// Rewrite a URL in a HTTP request from external to internal representation
        ///
        /// </summary>
        /// <param name="url">The URL, possibly rewritten</param>
        /// <remarks>
        /// Rewrites to internal representation, typically EPiServer classic with id= and epslanguage=,
        ///             taking care not to rewrite certain "untouchable" directories. Will also strip id= in all
        ///             other cases to comply with the requirement that site enumeration should not be possible.
        ///
        /// </remarks>
        protected override void HttpUrlRewriteToInternal(UrlBuilder url)
        {
            EPiServer.Web.UrlRewriteEventArgs e = new EPiServer.Web.UrlRewriteEventArgs(url, new EPiServer.Web.UrlRewriteEventArgs.Context(this.UrlInternal, this.UrlExternal));
            this.OnHttpRewritingToInternal(e);
            if (e.Cancel)
            {
                if (!UrlRewriteModule._log.IsDebugEnabled)
                    return;
                UrlRewriteModule._log.DebugFormat("Further URL rewriting stopped. Returning URL {0}", (object)e.Url);
            }
            else
            {
                Global.UrlRewriteProvider.ValidateRewriteToInternal(e, this.UrlExternal.Path);
                if (e.Cancel)
                {
                    if (!UrlRewriteModule._log.IsDebugEnabled)
                        return;
                    UrlRewriteModule._log.DebugFormat("Url is not valid for rewrite. Returning URL {0}", (object)e.Url);
                }
                else
                {
                    CultureInfo preferredCulture;
                    object internalObject;
                    if (Global.UrlRewriteProvider.TryConvertToInternal(e.Url, out preferredCulture, out internalObject))
                    {
                        if (internalObject is RedirectPageReference)
                        {
                            if ((string)e.Url == (string)this.UrlExternal)
                            {
                                HttpContext.Current.Response.End();
                                return;
                            }
                            else
                            {
                                HttpContext.Current.Response.Redirect((string)e.Url, true);
                                return;
                            }
                        }
                        else
                        {
                            if (preferredCulture != null)
                                ContentLanguage.PreferredCulture = preferredCulture;
                            e.IsModified = true;
                            ContentReference contentReference = internalObject as ContentReference;
                            if (UrlRewriteModule._log.IsDebugEnabled)
                                UrlRewriteModule._log.DebugFormat("Returning URL {0} as PageReference {0}", (object)e.Url, contentReference == (ContentReference)null ? (object)"(NULL)" : (object)contentReference.ToString());
                        }
                    }
                    else if (UrlRewriteModule._log.IsDebugEnabled)
                        UrlRewriteModule._log.DebugFormat("Returning URL {0}", (object)e.Url.ToString());
                    this.OnHttpRewroteToInternal(e);
                }
            }
        }

        /// <summary>
        /// Rewrite a URL om a HTTP request from internal to external.
        ///
        /// </summary>
        /// <param name="url">The URL.</param><param name="typeOfUrl">The type of rebasing to perform on the url.</param>
        /// <returns>
        /// The rewritten request URL
        /// </returns>
        protected override string HttpUrlRewriteToExternal(string url, UrlBuilder.RebaseKind typeOfUrl)
        {
            EPiServer.Web.UrlRewriteEventArgs e;
            try
            {
                e = new EPiServer.Web.UrlRewriteEventArgs(new UrlBuilder(url), new EPiServer.Web.UrlRewriteEventArgs.Context(this.UrlInternal, this.UrlExternal));
            }
            catch (UriFormatException ex)
            {
                UrlRewriteModule._log.Warn((object)string.Format("The URL '{0}' was not handled.", (object)url), (Exception)ex);
                return url;
            }
            this.OnHttpRewritingToExternal(e);
            if (e.Cancel)
            {
                if (UrlRewriteModule._log.IsDebugEnabled)
                    UrlRewriteModule._log.DebugFormat("Further URL rewriting stopped. Returning URL {0}", (object)e.Url);
                return UrlRewriteModule.GetEventReturnUrl(e, url);
            }
            else
            {
                Global.UrlRewriteProvider.ValidateRewriteToExternal(e, this.UrlInternal.Path);
                if (e.Cancel)
                {
                    if (UrlRewriteModule._log.IsDebugEnabled)
                        UrlRewriteModule._log.DebugFormat("Url is not valid for rewrite. Returning URL {0}", (object)e.Url);
                    return UrlRewriteModule.GetEventReturnUrl(e, url);
                }
                else
                {
                    ContentReference contentReference = EPiServer.Web.PermanentLinkUtility.GetContentReference(e.Url);
                    if (Global.UrlRewriteProvider.ConvertToExternal(e.Url, (object)contentReference, HttpContext.Current.Response.ContentEncoding))
                    {
                        e.IsModified = true;
                        if (UrlRewriteModule._log.IsDebugEnabled)
                            UrlRewriteModule._log.DebugFormat("Url was rewritten by the provider to {0}", (object)e.Url);
                        if (!string.IsNullOrEmpty(e.Url.QueryCollection["id"]))
                        {
                            e.Url.QueryCollection.Remove("id");
                            e.IsModified = true;
                        }
                    }
                    EPiServer.Web.UrlRewriteEventArgs rewriteEventArgs = e;
                    int num = rewriteEventArgs.IsModified | e.Url.Rebase(this.UrlInternal, this.UrlExternal, typeOfUrl) ? 1 : 0;
                    rewriteEventArgs.IsModified = num != 0;
                    this.OnHttpRewroteToExternal(e);
                    return UrlRewriteModule.GetEventReturnUrl(e, url);
                }
            }
        }

        /// <summary>
        /// Connect a filter for rewriting of outgoing HTML, and perform other actions before actually sending the HTML
        ///
        /// </summary>
        /// <param name="httpApplication"/>
        public override void HtmlAddRewriteToExternalFilter(HttpApplication httpApplication)
        {
            if (EPiServer.BaseLibrary.Context.Current["EP:validationDone"] != null)
                return;
            EPiServer.BaseLibrary.Context.Current["EP:validationDone"] = (object)true;
            if (!this.FURLRewriteResponse)
                return;
            EPiServer.Web.UrlRewriteEventArgs e = new EPiServer.Web.UrlRewriteEventArgs(this.UrlExternal);
            e.Internal = (object)httpApplication;
            this.OnHtmlAddingRewriteToExternalFilter(e);
            if (e.Cancel && !e.ForceRewriteHtml)
                return;
            this.ValidateRewriteHtmlToExternal(e);
            if (e.Cancel && !e.ForceRewriteHtml)
                return;
            EPiServer.Web.RewritePipe rewritePipe;
            Stream rewriteFilter = Global.UrlRewriteProvider.GetHtmlRewriter().GetRewriteFilter(this.UrlInternal, this.UrlExternal, httpApplication.Context.Response.ContentEncoding, httpApplication.Context.Response.Filter, out rewritePipe);
            httpApplication.Context.Response.Filter = rewriteFilter;
            this.OnHtmlAddedRewriteToExternalFilter(e);
        }

        /// <summary>
        /// Check if we should rewrite outgoing HTML. e.Cancel will be set to true if we should not.
        ///
        /// </summary>
        /// <param name="e">The <see cref="T:EPiServer.Web.UrlRewriteEventArgs"/> instance containing the event data.</param>
        protected virtual void ValidateRewriteHtmlToExternal(EPiServer.Web.UrlRewriteEventArgs e)
        {
            e.Cancel = !string.Equals(HttpContext.Current.Response.ContentType, "text/html", StringComparison.OrdinalIgnoreCase);
            if (e.Cancel)
            {
                e.Cancel = !EPiServer.Web.UpdatePanelPostBackRewritePipe.IsUpdatePanelPostback;
                if (e.Cancel)
                    return;
            }
            e.Cancel = HttpContext.Current.Response.StatusCode == 304;
            if (e.Cancel)
                return;
            Page page = HttpContext.Current.Handler as Page;
            if (page != null)
                e.Cancel = page.IsCallback;
            if (EPiServer.Web.HttpRequestSupport.IsRequestSystemDirectory && !UrlRewriteModule.RoutedThroughCMSRoute())
                e.Cancel = true;
            if (HttpContext.Current.Handler != null)
                return;
            e.Cancel = true;
        }

        private static bool RoutedThroughCMSRoute()
        {
            RouteData routeData = RouteTable.Routes.GetRouteData((HttpContextBase)new HttpContextWrapper(HttpContext.Current));
            return routeData != null && !ContentReference.IsNullOrEmpty(routeData.DataTokens[RoutingConstants.NodeKey] as ContentReference);
        }

        private static string GetEventReturnUrl(EPiServer.Web.UrlRewriteEventArgs e, string url)
        {
            if (!e.IsModified)
                return url;
            else
                return (string)e.Url;
        }
    }
}