/// <summary>
 /// Construtor padrão.
 /// </summary>
 /// <param name="name"></param>
 /// <param name="parent"></param>
 /// <param name="info"></param>
 public RouteInfoNavigate(string name, RouteInfoNavigate parent, RouteInfo info)
 {
     _uniqueID = Guid.NewGuid();
     _name     = name;
     _parent   = parent;
     _info     = info;
 }
Exemple #2
0
 /// <summary>
 /// Construtor padrão.
 /// </summary>
 /// <param name="virtualPath">Caminho virtual que o resultado representa.</param>
 /// <param name="info"></param>
 /// <param name="complexValues"></param>
 public LoadRouteResult(string virtualPath, RouteInfoNavigate info, List <KeyValuePair <int, string> > complexValues)
 {
     VirtualPath   = virtualPath;
     Navigate      = info;
     ComplexValues = complexValues;
 }
Exemple #3
0
 /// <summary>
 /// Carrega uma informação de route com base no virtual path informado.
 /// </summary>
 /// <param name="virtualPath"></param>
 /// <returns></returns>
 private static LoadRouteResult LoadRoute(string virtualPath)
 {
     try
     {
         string loc = "";
         if (!string.IsNullOrEmpty(virtualPath) && virtualPath[0] == '~')
         {
             loc = virtualPath.Substring(1);
         }
         else
         {
             loc = virtualPath;
         }
         if (!string.IsNullOrEmpty(loc) && loc[0] == '/')
         {
             loc = loc.Substring(1);
         }
         loc = loc.ToLower();
         if (RouteSettings.IgnoreRoutes.Count > 0 && RouteSettings.IgnoreRoutes.Exists(f => f.Length <= loc.Length && loc.IndexOf(f, StringComparison.InvariantCultureIgnoreCase) == 0))
         {
             return(null);
         }
         RouteInfoNavigate routeNavInfo = null;
         string            findKey      = null;
         foreach (var i in RouteSettings.RoutesNavigate.Keys)
         {
             if (loc.Length >= i.Length && loc.IndexOf(i, 0, i.Length, StringComparison.InvariantCultureIgnoreCase) == 0 && (findKey == null || i.Length > findKey.Length))
             {
                 findKey = i;
             }
         }
         if (!string.IsNullOrEmpty(findKey))
         {
             routeNavInfo = (RouteInfoNavigate)RouteSettings.RoutesNavigate[findKey];
         }
         Match             findMatch      = null;
         RouteInfoNavigate findComplexNav = null;
         lock (RouteSettings.ComplexRoutesNavigate)
             foreach (KeyValuePair <string, RouteInfoNavigate> i in RouteSettings.ComplexRoutesNavigate)
             {
                 var m = Regex.Match(loc, i.Key, RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture);
                 if (m.Success && m.Index == 0)
                 {
                     findComplexNav = i.Value;
                     findMatch      = m;
                 }
             }
         if (routeNavInfo != null && findComplexNav != null)
         {
             var complexUrl    = findComplexNav.Info.Location;
             var routeLocation = routeNavInfo.Info.Location;
             for (int i = 0; i < findComplexNav.ComplexPartsCount; i++)
             {
                 complexUrl = complexUrl.Replace("{" + i + "}", findMatch.Groups["complex" + i].Value);
             }
             if (routeLocation.Length > 0 && routeLocation[routeLocation.Length - 1] != '/')
             {
                 routeLocation += '/';
             }
             if (complexUrl.Length > 0 && complexUrl[complexUrl.Length - 1] != '/')
             {
                 complexUrl += '/';
             }
             if (complexUrl.Length < routeNavInfo.Info.Location.Length || string.Compare(complexUrl, routeLocation, true) == 0)
             {
                 return(new LoadRouteResult(virtualPath, routeNavInfo, null));
             }
         }
         if (findComplexNav != null)
         {
             var groupValues = new List <KeyValuePair <int, string> >();
             if (findMatch != null)
             {
                 for (int i = 0; i < findComplexNav.ComplexPartsCount; i++)
                 {
                     groupValues.Add(new KeyValuePair <int, string>(i, findMatch.Groups["complex" + i].Value));
                 }
             }
             return(new LoadRouteResult(virtualPath, findComplexNav, groupValues));
         }
         if (routeNavInfo != null)
         {
             return(new LoadRouteResult(virtualPath, routeNavInfo, null));
         }
     }
     catch (Exception ex1)
     {
         throw new Exception(string.Format("Fail on process route to \"{0}\".", virtualPath), ex1);
     }
     return(null);
 }
        public static void AddRouteInfo(string name, string location, string destinationPage, string path, string compiled, string actionName, string isDirectory, string isSecurePage, string forceNoSecurePage)
        {
            if (string.IsNullOrEmpty(path))
            {
                path = "*";
            }
            else
            {
                path = path.Replace(".", "").Replace(" ", "");
            }
            bool isCompiled = true;

            if (!bool.TryParse(compiled, out isCompiled))
            {
                isCompiled = true;
            }
            bool isDirectory1 = false;

            if (!bool.TryParse(isDirectory, out isDirectory1))
            {
                isDirectory1 = false;
            }
            bool isSecurePage1 = false;

            if (!bool.TryParse(isSecurePage, out isSecurePage1))
            {
                isSecurePage1 = false;
            }
            bool forceNoSecurePage1 = false;

            if (!bool.TryParse(forceNoSecurePage, out forceNoSecurePage1))
            {
                forceNoSecurePage1 = false;
            }
            RouteInfo info = new RouteInfo(name, location, destinationPage, path, isCompiled, actionName, isDirectory1, isSecurePage1, forceNoSecurePage1);
            string    loc  = "";

            if (!string.IsNullOrEmpty(info.Location) && info.Location[0] == '~')
            {
                loc = info.Location.Substring(1);
            }
            else
            {
                loc = info.Location;
            }
            if (!string.IsNullOrEmpty(loc) && loc[0] == '/')
            {
                loc = loc.Substring(1);
            }
            loc = loc.ToLower();
            var complexParts = Regex.Matches(loc, "{(?<part>[0-9]*?)}", RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture);

            if (complexParts.Count > 0)
            {
                var complexRegex = loc;
                if (complexParts.Count == 1 && complexParts[0].Index == 0 && complexParts[0].Length == complexRegex.Length)
                {
                    complexRegex = "((?<complex" + complexParts[0].Groups["part"].Value + ">[\\s\\S]*?)/)|(?<complex" + complexParts[0].Groups["part"].Value + ">[\\s\\S]*)";
                }
                else
                {
                    foreach (Match i in complexParts)
                    {
                        if ((i.Index + i.Length == loc.Length))
                        {
                            complexRegex = complexRegex.Replace(i.Value, "(((?<complex" + i.Groups["part"].Value + ">[\\s\\S]*?)/)|(?<complex" + i.Groups["part"].Value + ">[\\s\\S]*))");
                        }
                        else
                        {
                            complexRegex = complexRegex.Replace(i.Value, "(?<complex" + i.Groups["part"].Value + ">[\\s\\S]*?)");
                        }
                    }
                }
                if (!_complexRoutesNavigate.ContainsKey(complexRegex))
                {
                    RouteInfoNavigate rNavAux = new RouteInfoNavigate(loc, null, info);
                    rNavAux.ComplexPartsCount = complexParts.Count;
                    rNavAux.ComplexRegex      = complexRegex;
                    _complexRoutesNavigate.Add(complexRegex, rNavAux);
                }
            }
            else if (!_routesNavigate.ContainsKey(loc))
            {
                RouteInfoNavigate rNavAux = new RouteInfoNavigate(loc, null, info);
                _routesNavigate.Add(loc, rNavAux);
            }
        }
Exemple #5
0
        private void PostResolveRequestCache(HttpContext context)
        {
            System.Diagnostics.Debug.Write("\r\n PostResolveRequestCache    -- " + context.Request.Path);
            var cacheItem         = context.Items[_requestCacheItemKey] as LoadRouteResult;
            RouteInfoNavigate nav = cacheItem != null ? cacheItem.Navigate : null;

            if (nav != null)
            {
                string   relative        = context.Request.AppRelativeCurrentExecutionFilePath.Substring(2) + context.Request.PathInfo;
                var      destinationPage = nav.Info.DestinationPage;
                string[] partsRelative   = relative.Split('/');
                string[] partsNav        = nav.FullName.Split('/');
                string[] extensions      = nav.Info.Path.Split(',');
                string   pageName        = null;
                string   pageExtension   = null;
                string   part            = partsRelative[partsRelative.Length - 1];
                if (string.IsNullOrEmpty(part))
                {
                    if (Array.FindIndex(extensions, delegate(string s) {
                        return(s == "*");
                    }) < 0)
                    {
                        return;
                    }
                    pageName = "";
                }
                else
                {
                    System.IO.FileInfo fi = new System.IO.FileInfo(partsRelative[partsRelative.Length - 1]);
                    pageExtension = fi.Extension;
                    if (partsRelative[partsRelative.Length - 1].IndexOf('.') >= 0)
                    {
                        int i = 0;
                        if (extensions.Length >= 1 && extensions[0] != "*")
                        {
                            for (i = 0; i < extensions.Length; i++)
                            {
                                if (string.Compare(fi.Extension.Substring(1), extensions[i].Trim(), true) == 0)
                                {
                                    break;
                                }
                            }
                            if (i == extensions.Length)
                            {
                                return;
                            }
                        }
                        if (fi.Extension.Length > 0)
                        {
                            pageName = fi.Name.Substring(0, fi.Name.Length - fi.Extension.Length);
                        }
                        else
                        {
                            pageName = fi.Name;
                        }
                    }
                    else
                    {
                        int i = 0;
                        for (i = 0; i < extensions.Length; i++)
                        {
                            if (extensions[i].Trim() == "*")
                            {
                                break;
                            }
                        }
                        if (i == extensions.Length)
                        {
                            return;
                        }
                        pageName = fi.Name;
                    }
                }
                var routeParameters = new System.Collections.Specialized.NameValueCollection();
                int count           = (pageName == null ? partsRelative.Length : (partsRelative.Length - 1));
                for (int i = partsNav.Length; i < count; i++)
                {
                    routeParameters.Add("param" + (i - partsNav.Length), partsRelative[i]);
                }
                if (pageName != null)
                {
                    routeParameters.Add("pageName", pageName);
                }
                if (pageExtension != null)
                {
                    routeParameters.Add("pageExtension", pageExtension);
                }
                if (nav.ComplexPartsCount > 0)
                {
                    try
                    {
                        var match = System.Text.RegularExpressions.Regex.Match(relative, nav.ComplexRegex, System.Text.RegularExpressions.RegexOptions.IgnoreCase | System.Text.RegularExpressions.RegexOptions.ExplicitCapture);
                        if (match.Success)
                        {
                            for (int i = 0; i < nav.ComplexPartsCount; i++)
                            {
                                routeParameters.Add("complex" + i, match.Groups["complex" + i].Value);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        throw new Exception(string.Format("Fail on process complex route for {0}.", relative), ex);
                    }
                }
                var originalQueryStringParameters = new System.Collections.Specialized.NameValueCollection();
                foreach (var i in context.Request.QueryString.AllKeys)
                {
                    originalQueryStringParameters.Add(i, context.Request.QueryString[i]);
                }
                var qsPos = destinationPage.IndexOf('?');
                if (qsPos >= 0)
                {
                    var queryStringItems = destinationPage.Substring(qsPos + 1).Split('&');
                    foreach (var i in queryStringItems)
                    {
                        var pos1 = i.IndexOf('=');
                        if (pos1 > 0)
                        {
                            routeParameters.Add(i.Substring(0, pos1), i.Substring(pos1 + 1));
                        }
                    }
                    destinationPage = destinationPage.Substring(0, qsPos);
                }
                var virtualPath = "";
                RouteActionResponse actionResponse = null;
                var isCompiled = nav.Info.Compiled;
                var startPos   = 0;
                if (nav.Info.IsDirectory)
                {
                    var relativeDir = relative.Length > cacheItem.FormattedLocation.Length ? relative.Substring(cacheItem.FormattedLocation.Length) : relative;
                    startPos = 0;
                    if (!string.IsNullOrEmpty(relativeDir))
                    {
                        while (startPos < relativeDir.Length && relativeDir[startPos] == '/' || relativeDir[startPos] == '\\')
                        {
                            startPos++;
                        }
                    }
                    destinationPage += (startPos > 0 ? relativeDir.Substring(startPos) : relativeDir);
                }
                startPos = 0;
                if (!string.IsNullOrEmpty(destinationPage))
                {
                    while (startPos < destinationPage.Length && destinationPage[startPos] == '/' || destinationPage[startPos] == '\\')
                    {
                        startPos++;
                    }
                }
                destinationPage = (startPos > 0 ? destinationPage.Substring(startPos) : destinationPage);
                if (!isCompiled)
                {
                    virtualPath    = "~/" + destinationPage;
                    actionResponse = nav.Info.PreLoad(new RouteActionRequest {
                        DestinationVirtualPath = virtualPath,
                        OriginalQueryString    = originalQueryStringParameters,
                        RouteParameters        = routeParameters,
                        Context = context
                    });
                    if (actionResponse != null && !string.IsNullOrEmpty(actionResponse.RedirectVirtualPath))
                    {
                        isCompiled  = actionResponse.Compiled;
                        virtualPath = actionResponse.RedirectVirtualPath;
                    }
                }
                else
                {
                    virtualPath    = "~/" + destinationPage;
                    actionResponse = nav.Info.PreLoad(new RouteActionRequest {
                        DestinationVirtualPath = virtualPath,
                        OriginalQueryString    = originalQueryStringParameters,
                        RouteParameters        = routeParameters,
                        Context = context
                    });
                    if (actionResponse != null && !string.IsNullOrEmpty(actionResponse.RedirectVirtualPath))
                    {
                        isCompiled  = actionResponse.Compiled;
                        virtualPath = actionResponse.RedirectVirtualPath;
                    }
                }
                IHttpHandler ret       = null;
                var          inputFile = context.Server.MapPath(virtualPath);
                if (actionResponse != null && actionResponse.RouteHandler != null)
                {
                    ret = actionResponse.RouteHandler;
                }
                else if (!isCompiled)
                {
                    ret = new NotCompiledRedirect {
                        Filename = inputFile
                    }
                }
                ;
                else if (string.Compare(System.IO.Path.GetExtension(inputFile), ".asmx", true) == 0)
                {
                    ret = (new System.Web.Services.Protocols.WebServiceHandlerFactory()).GetHandler(context, "*", virtualPath, inputFile);
                }
                else
                {
                    ret = PageParser.GetCompiledPageInstance(virtualPath, inputFile, context);
                }
                RequestData data2 = new RequestData();
                data2.OriginalPath = context.Request.Path;
                data2.OriginalQueryStringParameters = originalQueryStringParameters;
                data2.HttpHandler              = ret;
                data2.RouteParameters          = routeParameters;
                data2.Route                    = nav.Info;
                context.Items[_requestDataKey] = data2;
                context.RewritePath("~/Route.axd");
            }
        }