public static RouteValueDictionary GetPageRoute(this RequestContext requestContext, ContentReference contentLink)
 {
     var values = new RouteValueDictionary();
     values[RoutingConstants.NodeKey] = contentLink;
     values[RoutingConstants.LanguageKey] = ContentLanguage.PreferredCulture.Name;
     return values;
 }

        public string GetRouteDescriptorKey(HttpContextBase httpContext, RouteBase routeBase) {
            var route = routeBase as Route;
            var dataTokens = new RouteValueDictionary();

            if (route != null) {
                dataTokens = route.DataTokens;
            }
            else {
            var routeData = routeBase.GetRouteData(httpContext);

                if (routeData != null) {
                    dataTokens = routeData.DataTokens;
                }
            }

            var keyBuilder = new StringBuilder();

            if (route != null) {
                keyBuilder.AppendFormat("url={0};", route.Url);
            }

            // the data tokens are used in case the same url is used by several features, like *{path} (Rewrite Rules and Home Page Provider)
            if (dataTokens != null) {
                foreach (var key in dataTokens.Keys) {
                    keyBuilder.AppendFormat("{0}={1};", key, dataTokens[key]);
                }
            }

            return keyBuilder.ToString().ToLowerInvariant();
        }

 public void RegisterRoutes(RouteCollection routes)
 {
     //Register 1 route
     var basePath = Config.GetBasePath();
     var constrasints = new RouteValueDictionary {{"method", new ApiHttpMethodConstraint("OPTIONS")}};
     routes.Add(new Route(basePath + "{*path}", null, constrasints, new ApiAccessRouteHandler()));
 }

        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            base.OnActionExecuting(filterContext);
            var principal = HttpContext.Current.User as IClaimsPrincipal;
            var buffer = new StringBuilder();

            if (principal != null && principal.Identity.IsAuthenticated)
            {
                foreach (var claim in Claims)
                {
                    if (!principal.Identities[0].Claims.Any(c => c.ClaimType == claim))
                    {
                        buffer.AppendLine(String.Format("Claim '{0}' not provided.", claim));
                    }
                }

                if (buffer.Length > 0)
                {
                    var redirectTargetDictionary = new RouteValueDictionary
                        {
                            {"action", "Error"},
                            {"controller", "Home"},
                            {"message", buffer.ToString()}
                        };

                    filterContext.Result = new RedirectToRouteResult(redirectTargetDictionary);
                }
            }
        }

        public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
        {
            VirtualPathData path = base.GetVirtualPath(requestContext, values);

            if (path != null)
            {
                string virtualPath = path.VirtualPath;
                var lastIndexOf = virtualPath.LastIndexOf("?");

                if (lastIndexOf != 0)
                {
                    if (lastIndexOf > 0)
                    {
                        string leftPart = virtualPath.Substring(0, lastIndexOf).ToLowerInvariant();
                        string queryPart = virtualPath.Substring(lastIndexOf);
                        path.VirtualPath = leftPart + queryPart;
                    }
                    else
                    {
                        path.VirtualPath = path.VirtualPath.ToLowerInvariant();
                    }
                }
            }

            return path;
        }

        private static string GetOutput(object tokenReplacements)
        {
            // Read the contents of the html template.
            var assembly = Assembly.GetExecutingAssembly();
            var fileName = "{0}.LogRoutes.html".FormatWith(typeof(LogRoutesHandler).Namespace);
            string fileContent;
            using (var stream = assembly.GetManifestResourceStream(fileName))
            {
                if (stream == null)
                    throw new AttributeRoutingException(
                        "The file \"{0}\" cannot be found as an embedded resource.".FormatWith(fileName));

                using (var reader = new StreamReader(stream))
                    fileContent = reader.ReadToEnd();
            }

            // Replace tokens in the template with appropriate content
            var outputBuilder = new StringBuilder(fileContent);

            var tokenReplacementsDictionary = new RouteValueDictionary(tokenReplacements);
            foreach (var key in tokenReplacementsDictionary.Keys)
                outputBuilder.Replace("{{{0}}}".FormatWith(key), tokenReplacementsDictionary[key].ToString());

            return outputBuilder.ToString();
        }

        public static string Generate(RequestContext requestContext, NavigationRequest navigationItem, RouteValueDictionary routeValues)
        {
            if (requestContext == null)
                throw new ArgumentNullException("requestContext");
            if (navigationItem == null)
                throw new ArgumentNullException("navigationItem");

            var urlHelper = new UrlHelper(requestContext);
            string generatedUrl = null;

            if (!string.IsNullOrEmpty(navigationItem.RouteName))
            {
                generatedUrl = urlHelper.RouteUrl(navigationItem.RouteName, routeValues);
            }
            else if (!string.IsNullOrEmpty(navigationItem.ControllerName) && !string.IsNullOrEmpty(navigationItem.ActionName))
            {
                generatedUrl = urlHelper.Action(navigationItem.ActionName, navigationItem.ControllerName, routeValues, null, null);
            }
            else if (!string.IsNullOrEmpty(navigationItem.Url))
            {
                generatedUrl = navigationItem.Url.StartsWith("~/", StringComparison.Ordinal) 
                    ? urlHelper.Content(navigationItem.Url) 
                    : navigationItem.Url;
            }
            else if (routeValues.Any())
            {
                generatedUrl = urlHelper.RouteUrl(routeValues);
            }

            return generatedUrl;

        }

        public static void RegisterRoutes(RouteCollection routes)
        {
            var def = new RouteValueDictionary(new { user = "demo" });
            var reg = new RouteValueDictionary(new { user = "\\w+" });

            // Register a route for Page/{User}
            routes.MapPageRoute(
               "user-page", // Route name
               "w/{user}", // Route URL
               "~/Pv.aspx", // Web page to handle route
               true,
               def,
               reg
            );
            // Register a route for Page/{User}
            routes.MapPageRoute(
               "user-card", // Route name
               "c/{user}", // Route URL
               "~/Cv.aspx", // Web page to handle route
               true,
               def,
               reg
            );
            // Register a route for Page/{User}
            routes.MapPageRoute(
               "user-imgs", // Route name
               "p/{user}", // Route URL
               "~/Id.aspx", // Web page to handle route
               true,
               def,
               reg
            );
        }

        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection) {

            object value;
            if (values.TryGetValue(parameterName, out value)) {
                var parameterValue = Convert.ToString(value);

                var path = FindPath(parameterValue);
                if (path == null) {
                    return false;
                }

                var archiveData = FindArchiveData(parameterValue);
                if (archiveData == null) {
                    return false;
                }

                try {
                    // is this a valid date ?
                    archiveData.ToDateTime();
                }
                catch {
                    return false;
                }

                var autoroute = _pathResolutionService.GetPath(path);

                return autoroute != null && autoroute.Is<BlogPart>();
            }

            return false;
        }

 /// <summary>
 /// Gets a route for provider configuration
 /// </summary>
 /// <param name="actionName">Action name</param>
 /// <param name="controllerName">Controller name</param>
 /// <param name="routeValues">Route values</param>
 public void GetConfigurationRoute(out string actionName, out string controllerName, out RouteValueDictionary routeValues)
 {
     // no configuration required
     actionName = null;
     controllerName = null;
     routeValues = null;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="httpContext"></param>
 /// <param name="route"></param>
 /// <param name="parameterName"></param>
 /// <param name="values"></param>
 /// <param name="routeDirection"></param>
 /// <returns></returns>
 public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
 {
     if (values[parameterName].ToString().ToLower() == "rqitems")
         return true;
     else
         return false;
 }

        private SiteMapNode AddNodeRecursive(XmlNode xmlNode, SiteMapNode parent, RequestContext context)
        {
            var routeValues = (from XmlNode attrib in xmlNode.Attributes
                               where !reservedNames.Contains(attrib.Name.ToLower())
                               select new { attrib.Name, attrib.Value }).ToDictionary(x => x.Name, x => (object)x.Value);

            RouteValueDictionary routeDict = new RouteValueDictionary(routeValues);
            VirtualPathData virtualPathData = RouteTable.Routes.GetVirtualPath(context, routeDict);

            if (virtualPathData == null)
            {
                string message = "RoutingSiteMapProvider is unable to locate Route for " +
                                 "Controller: '" + routeDict["controller"] + "', Action: '" + routeDict["action"] + "'. " +
                                 "Make sure a route has been defined for this SiteMap Node.";
                throw new InvalidOperationException(message);
            }

            string url = virtualPathData.VirtualPath;

            string title = xmlNode.Attributes["title"].Value;
            SiteMapNode node = new SiteMapNode(this, Guid.NewGuid().ToString(), url, title);

            base.AddNode(node, parent);

            foreach (XmlNode childNode in xmlNode.ChildNodes)
            {
                AddNodeRecursive(childNode, node, context);
            }

            return node;
        }

        // TODO: Remove when https://github.com/aspnet/Mvc/issues/4846 is fixed
        public static IRouteBuilder MapAreaRoute(this IRouteBuilder routeBuilder,
            string name,
            string area,
            string template,
            string controller,
            string action)
        {
            if (routeBuilder == null)
            {
                throw new ArgumentNullException(nameof(routeBuilder));
            }

            if (string.IsNullOrEmpty(area))
            {
                throw new ArgumentException(nameof(area));
            }

            var defaultsDictionary = new RouteValueDictionary();
            defaultsDictionary["area"] = area;
            defaultsDictionary["controller"] = controller;
            defaultsDictionary["action"] = action;

            var constraintsDictionary = new RouteValueDictionary();
            constraintsDictionary["area"] = new StringRouteConstraint(area);

            routeBuilder.MapRoute(name, template, defaultsDictionary, constraintsDictionary, null);
            return routeBuilder;
        }

 // To only allow *supported* cultures as the first part of the route, instead of  anything in the format xx or xx-xx comment the lower method
 // and uncomment this one, and make CultureManager.CultureIsSupported public.
 //public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
 //{
 //    if (!values.ContainsKey(parameterName))
 //        return false;
 //    string potentialCultureName = (string)values[parameterName];
 //    return CultureManager.CultureIsSupported(potentialCultureName);
 //}
 public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
 {
     if (!values.ContainsKey(parameterName))
         return false;
     string potentialCultureName = (string)values[parameterName];
     return CultureFormatChecker.FormattedAsCulture(potentialCultureName);
 }

 public ActionLink BuildLink(Theme theme)
 {
     RouteValueDictionary routeValueDictionary = new RouteValueDictionary();
     routeValueDictionary.Add("id", theme.Id);
     ActionLink actionLink = new ActionLink("Play", "Training", routeValueDictionary);
     return actionLink;
 }

 public static RouteValueDictionary MergeRouteValues(string actionName, string controllerName,
     RouteValueDictionary implicitRouteValues,
     RouteValueDictionary routeValues,
     bool includeImplicitMvcValues)
 {
     var routeValueDictionary = new RouteValueDictionary();
     if (includeImplicitMvcValues)
     {
         object obj;
         if (implicitRouteValues != null && implicitRouteValues.TryGetValue("action", out obj))
         {
             routeValueDictionary["action"] = obj;
         }
         if (implicitRouteValues != null && implicitRouteValues.TryGetValue("controller", out obj))
         {
             routeValueDictionary["controller"] = obj;
         }
     }
     if (routeValues != null)
     {
         foreach (var keyValuePair in GetRouteValues(routeValues))
         {
             routeValueDictionary[keyValuePair.Key] = keyValuePair.Value;
         }
     }
     if (actionName != null)
     {
         routeValueDictionary["action"] = actionName;
     }
     if (controllerName != null)
     {
         routeValueDictionary["controller"] = controllerName;
     }
     return routeValueDictionary;
 }

 public static string SubdomainAction(this UrlHelper urlHelper, string actionName, string controllerName,
     string areaName = "")
 {
     var routeValues = new RouteValueDictionary { { "area", areaName } };
     string baseUrl = GetDomainBase(urlHelper, null, actionName, controllerName, routeValues);
     return BuildUri(baseUrl, urlHelper.Action(actionName, controllerName, routeValues));
 }

        public static IDisposable Begin(string tagName, TextWriter writer, RouteValueDictionary htmlAttributes)
        {
            var tag = new TagBuilder(tagName);
            tag.MergeAttributes(htmlAttributes);

            return new TagWrapper(tag, writer);
        }

 /// <summary>
 /// Creates a new <see cref="VirtualPathContext"/>.
 /// </summary>
 /// <param name="httpContext">The <see cref="Http.HttpContext"/> associated with the current request.</param>
 /// <param name="ambientValues">The set of route values associated with the current request.</param>
 /// <param name="values">The set of new values provided for virtual path generation.</param>
 public VirtualPathContext(
     HttpContext httpContext,
     RouteValueDictionary ambientValues,
     RouteValueDictionary values)
     : this(httpContext, ambientValues, values, null)
 {
 }

 /// <summary>
 /// The modal dialog action link.
 /// </summary>
 /// <param name="ajaxHelper">Um Helper Ajax.</param>
 /// <param name="linkText">O texto a ser exibido no link</param>
 /// <param name="actionName">A Action a ser executada quando o link for clicado</param>
 /// <param name="controllerName">O nome do controller</param>
 /// <param name="dialogTitle">O título do modal popUp a ser exibido</param>
 /// <param name="routeValues">Valores de Rota</param>
 /// <param name="htmlAttributes">html atributes</param>
 /// <param name="onSubmitJsCallback">
 /// Um Callback JS a ser executado após o submit
 /// <para></para>
 /// Este callback deve ser criado de forma a receber uma conjunto de dados no formato Json.
 /// Ex: function callback(data){}
 /// Para informar quais dados devem ser submetidos, deve-se retornar um <see cref="DialogResult(System.Web.Mvc.Controller,string,object)"/>, 
 /// endo o último parâmetro, um <see cref="object"/> que será serializado.
 /// Após a submissão do formulário, caso não seja especificado um callback, os dados serão descartados.
 /// </param>
 /// <returns>The <see cref="MvcHtmlString"/>.</returns>
 public static MvcHtmlString ModalDialogActionLink(
     this AjaxHelper ajaxHelper,
     string linkText,
     string actionName,
     string controllerName,
     string dialogTitle,
     RouteValueDictionary routeValues,
     IDictionary<string, object> htmlAttributes,
     string onSubmitJsCallback)
 {
     if (routeValues == null)
     {
         routeValues = new RouteValueDictionary();
     }
     
     var dialogDivId = Guid.NewGuid().ToString();
     return ajaxHelper.ActionLink(
         linkText,
         actionName,
         controllerName,
         routeValues: routeValues,
         ajaxOptions:
             new AjaxOptions
             {
                 UpdateTargetId = dialogDivId,
                 InsertionMode = InsertionMode.Replace,
                 HttpMethod = "GET",
                 OnBegin = string.Format(CultureInfo.InvariantCulture, "prepareModalDialog('{0}')", dialogDivId),
                 OnFailure = string.Format(CultureInfo.InvariantCulture, "clearModalDialog('{0}');alert('Ajax call failed')", dialogDivId),
                 OnSuccess = string.Format(CultureInfo.InvariantCulture, "openModalDialog('{0}', '{1}', {2})", dialogDivId, dialogTitle, onSubmitJsCallback)
             },
         htmlAttributes: htmlAttributes);
 }