MonoRail/Castle.MonoRail.Framework/RoutingModule.cs

   1 // Copyright 2004-2007 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.MonoRail.Framework
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Web;
  20         using Castle.MonoRail.Framework.Configuration;
  21
  22         /// <summary>
  23         /// Provides routing basic services in response to rules defined in
  24         /// <see cref="MonoRailConfiguration.RoutingRules"/>.
  25         /// <remarks>
  26         /// This class delegates the resolving of the path that will be evaluated
  27         /// to derivided classes.
  28         /// </remarks>
  29         /// </summary>
  30         public class RoutingModule : IHttpModule
  31         {
  32                 internal static readonly String OriginalPathKey = "rails.original_path";
  33                 private IList routingRules;
  34
  35                 /// <summary>
  36                 /// Initializes a module and prepares it to handle requests.
  37                 /// </summary>
  38                 /// <param name="context">An <see cref="T:System.Web.HttpApplication"></see> that provides access to the methods, properties, and events common to all application objects within an ASP.NET application</param>
  39                 public void Init(HttpApplication context)
  40                 {
  41                         context.BeginRequest += OnBeginRequest;
  42
  43                         routingRules = MonoRailConfiguration.GetConfig().RoutingRules;
  44                 }
  45
  46                 /// <summary>
  47                 /// Disposes of the resources (other than memory) used by the module that implements <see cref="T:System.Web.IHttpModule"></see>.
  48                 /// </summary>
  49                 public void Dispose()
  50                 {
  51                 }
  52
  53                 /// <summary>
  54                 /// Called when [begin request].
  55                 /// </summary>
  56                 /// <param name="sender">The sender.</param>
  57                 /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
  58                 private void OnBeginRequest(object sender, EventArgs e)
  59                 {
  60                         if (routingRules.Count == 0) return;
  61
  62                         HttpContext context = HttpContext.Current;
  63                         HttpRequest request = context.Request;
  64
  65                         String newPath;
  66
  67                         String sourcePath = GetSourcePath();
  68
  69                         SaveOriginalPath(context, sourcePath);
  70
  71                         if (FindMatchAndReplace(sourcePath, out newPath))
  72                         {
  73                                 // Handle things differently depending on wheter we need
  74                                 // to keep a query string or not
  75
  76                                 int queryStringIndex = newPath.IndexOf('?');
  77
  78                                 if (queryStringIndex == -1)
  79                                 {
  80                                         context.RewritePath(newPath);
  81                                 }
  82                                 else
  83                                 {
  84                                         String path = newPath.Substring(0, queryStringIndex);
  85                                         String queryString = newPath.Substring(queryStringIndex + 1);
  86                                         context.RewritePath(path, request.PathInfo, queryString);
  87                                 }
  88                         }
  89                 }
  90
  91                 /// <summary>
  92                 /// Gets the source path.
  93                 /// </summary>
  94                 /// <returns></returns>
  95                 protected static string GetSourcePath()
  96                 {
  97                         if (ShouldUseHostAndPath)
  98                         {
  99                                 return GetHostNameAndPath();
 100                         }
 101                         else if (ExcludeAppPath)
 102                         {
 103                                 return GetPathWithoutAppPath();
 104                         }
 105                         else
 106                         {
 107                                 return GetPath();
 108                         }
 109                 }
 110
 111                 private static bool ShouldUseHostAndPath
 112                 {
 113                         get
 114                         {
 115                                 return MonoRailConfiguration.GetConfig().MatchHostNameAndPath;
 116                         }
 117                 }
 118
 119                 private static bool ExcludeAppPath
 120                 {
 121                         get
 122                         {
 123                                 return MonoRailConfiguration.GetConfig().ExcludeAppPath;
 124                         }
 125                 }
 126
 127                 private static string GetHostNameAndPath()
 128                 {
 129                         HttpContext context = HttpContext.Current;
 130                         HttpRequest request = context.Request;
 131
 132                         String host = request.Headers["host"];
 133
 134                         if (String.IsNullOrEmpty(host))
 135                         {
 136                                 return request.FilePath;
 137                         }
 138                         else
 139                         {
 140                                 return host + request.FilePath;
 141                         }
 142                 }
 143
 144                 private static string GetPathWithoutAppPath()
 145                 {
 146                         //if ApplicationPath.Length == 1 then it must be "/" which we don't want to remove
 147
 148                         string appPath = HttpContext.Current.Request.ApplicationPath;
 149                         string filePath = HttpContext.Current.Request.FilePath;
 150
 151                         return (appPath.Length == 1) ? filePath : filePath.Remove(0, appPath.Length);
 152                 }
 153
 154                 private static string GetPath()
 155                 {
 156                         return HttpContext.Current.Request.FilePath;
 157                 }
 158
 159                 private bool FindMatchAndReplace(String currentPath, out String newPath)
 160                 {
 161                         newPath = String.Empty;
 162
 163                         foreach(RoutingRule rule in routingRules)
 164                         {
 165                                 if (rule.CompiledRule.IsMatch(currentPath))
 166                                 {
 167                                         newPath = rule.CompiledRule.Replace(currentPath, rule.Replace);
 168
 169                                         //Append the query string
 170                                         String queryString = HttpContext.Current.Request.Url.Query;
 171
 172                                         if (queryString.Length > 0)
 173                                         {
 174                                                 //If we already have some query string params on the new path...
 175                                                 bool hasParams = (newPath.LastIndexOf("?") != -1);
 176
 177                                                 if (hasParams)
 178                                                 {
 179                                                         //...make sure we append the query string nicely rather than adding another ?
 180                                                         queryString = queryString.Replace("?", "&");
 181                                                 }
 182
 183                                                 newPath += queryString;
 184                                         }
 185
 186                                         if (ExcludeAppPath)
 187                                         {
 188                                                 string appPath = HttpContext.Current.Request.ApplicationPath;
 189
 190                                                 if (appPath.Length > 1)
 191                                                 {
 192                                                         newPath = appPath + newPath;
 193                                                 }
 194                                         }
 195
 196                                         return true;
 197                                 }
 198                         }
 199
 200                         return false;
 201                 }
 202
 203                 /// <summary>
 204                 /// Returns the original path
 205                 /// (before rewriting occured), or <c>null</c>
 206                 /// if rewriting didn't occur on this request.
 207                 /// </summary>
 208                 public static String OriginalPath
 209                 {
 210                         get
 211                         {
 212                                 HttpContext context = HttpContext.Current;
 213
 214                                 if (context.Items.Contains(OriginalPathKey))
 215                                 {
 216                                         return context.Items[OriginalPathKey] as String;
 217                                 }
 218
 219                                 return null;
 220                         }
 221                 }
 222
 223                 private static void SaveOriginalPath(HttpContext context, String virtualPath)
 224                 {
 225                         context.Items.Add(OriginalPathKey, virtualPath);
 226                 }
 227         }
 228 }