MonoRail/Castle.MonoRail.Framework/Services/DefaultUrlBuilder.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.Services
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Specialized;
  20         using Castle.Core;
  21         using Castle.MonoRail.Framework.Internal;
  22         using Framework;
  23
  24         /// <summary>
  25         /// Default implementation of <see cref="IUrlBuilder"/>
  26         /// </summary>
  27         /// <remarks>
  28         /// The property <see cref="UseExtensions"/> defines whether the builder should output
  29         /// file extension. This might be handy to use in combination with a url rewrite strategy
  30         ///
  31         /// <para>
  32         /// If you want to create a custom urlbuilder, you can extend this one and override
  33         /// the <see cref="InternalBuildUrl(string,string,string,string,string,string,string,string,string,bool,bool,string)"/>
  34         /// </para>
  35         ///
  36         /// </remarks>
  37         /// <seealso cref="BuildUrl(UrlInfo,IDictionary)"/>
  38         public class DefaultUrlBuilder : IUrlBuilder, IServiceEnabledComponent
  39         {
  40                 private bool useExtensions = true;
  41                 private IServerUtility serverUtil;
  42                 private IRoutingEngine routingEng;
  43
  44                 /// <summary>
  45                 /// Initializes a new instance of the <see cref="DefaultUrlBuilder"/> class.
  46                 /// </summary>
  47                 public DefaultUrlBuilder()
  48                 {
  49                 }
  50
  51                 #region Properties
  52
  53                 /// <summary>
  54                 /// Gets or sets a value indicating whether the builder should output an extension.
  55                 /// </summary>
  56                 /// <value><c>true</c> if should use extensions; otherwise, <c>false</c>.</value>
  57                 public bool UseExtensions
  58                 {
  59                         get { return useExtensions; }
  60                         set { useExtensions = value; }
  61                 }
  62
  63                 /// <summary>
  64                 /// Gets or sets the server utility instance.
  65                 /// </summary>
  66                 /// <value>The server util.</value>
  67                 public IServerUtility ServerUtil
  68                 {
  69                         get { return serverUtil; }
  70                         set { serverUtil = value; }
  71                 }
  72
  73                 /// <summary>
  74                 /// Gets or sets the routing engine.
  75                 /// </summary>
  76                 /// <value>The routing engine.</value>
  77                 public IRoutingEngine RoutingEngine
  78                 {
  79                         get { return routingEng; }
  80                         set { routingEng = value; }
  81                 }
  82
  83                 #endregion
  84
  85                 #region IServiceEnabledComponent
  86
  87                 /// <summary>
  88                 /// Services the specified provider.
  89                 /// </summary>
  90                 /// <param name="provider">The provider.</param>
  91                 public void Service(IServiceProvider provider)
  92                 {
  93                         serverUtil = (IServerUtility) provider.GetService(typeof(IServerUtility));
  94                         routingEng = (IRoutingEngine) provider.GetService(typeof(IRoutingEngine));
  95                 }
  96
  97                 #endregion
  98
  99                 #region IUrlBuilder
 100
 101                 /// <summary>
 102                 /// Builds the URL using the current url as contextual information and a parameter dictionary.
 103                 /// <para>
 104                 /// Common parameters includes area, controller and action.
 105                 /// </para>
 106                 /// </summary>
 107                 /// <param name="current">The current Url information.</param>
 108                 /// <param name="parameters">The parameters.</param>
 109                 /// <returns></returns>
 110                 public UrlPartsBuilder CreateUrlPartsBuilder(UrlInfo current, IDictionary parameters)
 111                 {
 112                         string routeName = CommonUtils.ObtainEntryAndRemove(parameters, "named");
 113                         bool encode = CommonUtils.ObtainEntryAndRemove(parameters, "encode", "false") == "true";
 114
 115                         if (routeName != null)
 116                         {
 117                                 object routeParams = parameters["params"];
 118                                 parameters.Remove("params");
 119
 120                                 return InternalBuildRouteUrl(current.Domain, current.AppVirtualDir, routeName, routeParams, encode);
 121                         }
 122                         else
 123                         {
 124                                 bool applySubdomain = false;
 125                                 bool createAbsolutePath = CommonUtils.ObtainEntryAndRemove(parameters, "absolute", "false") == "true";
 126
 127                                 string area;
 128
 129                                 if (parameters.Contains("area"))
 130                                 {
 131                                         area = CommonUtils.ObtainEntryAndRemove(parameters, "area");
 132
 133                                         if (area == null) area = string.Empty;
 134                                 }
 135                                 else
 136                                 {
 137                                         area = current.Area;
 138                                 }
 139
 140                                 string controller = CommonUtils.ObtainEntryAndRemove(parameters, "controller", current.Controller);
 141                                 string action = CommonUtils.ObtainEntryAndRemove(parameters, "action", current.Action);
 142
 143                                 string domain = CommonUtils.ObtainEntryAndRemove(parameters, "domain", current.Domain);
 144                                 string subdomain = CommonUtils.ObtainEntryAndRemove(parameters, "subdomain", current.Subdomain);
 145                                 string protocol = CommonUtils.ObtainEntryAndRemove(parameters, "protocol", current.Protocol);
 146                                 string port = CommonUtils.ObtainEntryAndRemove(parameters, "port", current.Port.ToString());
 147                                 string pathInfo = CommonUtils.ObtainEntryAndRemove(parameters, "pathinfo");
 148                                 string suffix = null;
 149
 150                                 object queryString = CommonUtils.ObtainObjectEntryAndRemove(parameters, "querystring");
 151
 152                                 string basePath = null;
 153
 154                                 if (parameters.Contains("basepath"))
 155                                 {
 156                                         basePath = CommonUtils.ObtainEntryAndRemove(parameters, "basepath");
 157                                 }
 158
 159                                 if (queryString != null)
 160                                 {
 161                                         if (queryString is IDictionary)
 162                                         {
 163                                                 IDictionary qsDictionary = (IDictionary) queryString;
 164
 165                                                 suffix = CommonUtils.BuildQueryString(serverUtil, qsDictionary, encode);
 166                                         }
 167                                         else if (queryString is NameValueCollection)
 168                                         {
 169                                                 suffix = CommonUtils.BuildQueryString(serverUtil, (NameValueCollection) queryString, encode);
 170                                         }
 171                                         else if (queryString is string)
 172                                         {
 173                                                 suffix = queryString.ToString();
 174                                         }
 175                                 }
 176
 177                                 if (subdomain.ToLower() != current.Subdomain.ToLower())
 178                                 {
 179                                         applySubdomain = true;
 180                                 }
 181
 182                                 return InternalBuildUrl(area, controller, action, protocol, port, domain, subdomain,
 183                                                         current.AppVirtualDir, current.Extension, createAbsolutePath, applySubdomain, suffix,
 184                                                         basePath, pathInfo);
 185                         }
 186                 }
 187
 188                 /// <summary>
 189                 /// Builds the URL using the current url as contextual information and a parameter dictionary.
 190                 ///
 191                 /// </summary>
 192                 ///
 193                 /// <remarks>
 194                 /// <para>
 195                 /// Common parameters includes <c>area</c>, <c>controller</c> and <c>action</c>, which outputs
 196                 /// <c>/area/controller/name.extension</c>
 197                 /// </para>
 198                 ///
 199                 /// <para>
 200                 /// Please note that if you dont specify an area or controller name, they will be inferred from the
 201                 /// context. If you want to use an empty area, you must specify <c>area=''</c>.
 202                 /// This is commonly a source of confusion, so understand the following cases:
 203                 /// </para>
 204                 ///
 205                 /// <example>
 206                 /// <code>
 207                 /// UrlInfo current = ... // Assume that the current is area Admin, controller Products and action List
 208                 ///
 209                 /// BuildUrl(current, {action: 'view'})
 210                 /// // returns /Admin/Products/view.castle
 211                 ///
 212                 /// BuildUrl(current, {controller: 'Home', action: 'index'})
 213                 /// // returns /Admin/Home/index.castle
 214                 ///
 215                 /// BuildUrl(current, {area:'', controller: 'Home', action: 'index'})
 216                 /// // returns /Home/index.castle
 217                 /// </code>
 218                 /// </example>
 219                 ///
 220                 /// <para>
 221                 /// The <c>querystring</c> parameter can be a string or a dictionary. It appends a query string to the url:
 222                 /// <c>/area/controller/name.extension?id=1</c>
 223                 /// </para>
 224                 ///
 225                 /// <para>
 226                 /// The <c>absolute</c> parameter forces the builder to output a full url like
 227                 /// <c>http://hostname/virtualdir/area/controller/name.extension</c>
 228                 /// </para>
 229                 ///
 230                 /// <para>
 231                 /// The <c>pathinfo</c> parameter can be used to add information between the resource identifier and the
 232                 /// query string (optional)
 233                 /// <c>http://hostname/virtualdir/area/controller/name.extension/path/info/here</c> or
 234                 /// <c>http://hostname/virtualdir/area/controller/name.extension/path/info/here?key=value</c>
 235                 /// </para>
 236                 ///
 237                 /// <para>
 238                 /// The <c>encode</c> parameter forces the builder to encode the querystring
 239                 /// <c>/controller/name.extension?id=1&amp;name=John</c> which is required to output full xhtml compliant content.
 240                 /// </para>
 241                 ///
 242                 /// </remarks>
 243                 /// <param name="current">The current Url information.</param>
 244                 /// <param name="parameters">The parameters.</param>
 245                 /// <returns></returns>
 246                 public virtual string BuildUrl(UrlInfo current, IDictionary parameters)
 247                 {
 248                         return CreateUrlPartsBuilder(current, parameters).BuildPath();
 249                 }
 250
 251                 /// <summary>
 252                 /// Pendent.
 253                 /// </summary>
 254                 /// <param name="current">The current.</param>
 255                 /// <param name="routeName">Name of the route.</param>
 256                 /// <returns></returns>
 257                 public string BuildRouteUrl(UrlInfo current, string routeName)
 258                 {
 259                         return InternalBuildRouteUrl(current.Domain, current.AppVirtualDir, routeName, null, false).BuildPath();
 260                 }
 261
 262                 /// <summary>
 263                 /// Pendent.
 264                 /// </summary>
 265                 /// <param name="current">The current.</param>
 266                 /// <param name="routeName">Name of the route.</param>
 267                 /// <param name="parameters">The parameters.</param>
 268                 /// <returns></returns>
 269                 public string BuildRouteUrl(UrlInfo current, string routeName, IDictionary parameters)
 270                 {
 271                         return InternalBuildRouteUrl(current.Domain, current.AppVirtualDir, routeName, parameters, false).BuildPath();
 272                 }
 273
 274                 /// <summary>
 275                 /// Pendent.
 276                 /// </summary>
 277                 /// <param name="current">The current.</param>
 278                 /// <param name="routeName">Name of the route.</param>
 279                 /// <param name="parameters">The parameters.</param>
 280                 /// <returns></returns>
 281                 public string BuildRouteUrl(UrlInfo current, string routeName, object parameters)
 282                 {
 283                         return InternalBuildRouteUrl(current.Domain, current.AppVirtualDir, routeName, parameters, false).BuildPath();
 284                 }
 285
 286                 /// <summary>
 287                 /// Builds an URL using the controller name and action name.
 288                 /// </summary>
 289                 /// <param name="current">The current Url information.</param>
 290                 /// <param name="controller">The controller.</param>
 291                 /// <param name="action">The action.</param>
 292                 /// <returns></returns>
 293                 public virtual string BuildUrl(UrlInfo current, string controller, string action)
 294                 {
 295                         Hashtable parameters = new Hashtable();
 296                         parameters["controller"] = controller;
 297                         parameters["action"] = action;
 298                         return BuildUrl(current, parameters);
 299                 }
 300
 301                 /// <summary>
 302                 /// Builds an URL using the controller name, action name, and a querystring dictionary.
 303                 /// </summary>
 304                 /// <param name="current">The current Url information.</param>
 305                 /// <param name="controller">The controller.</param>
 306                 /// <param name="action">The action.</param>
 307                 /// <param name="queryStringParams">The query string params.</param>
 308                 /// <returns></returns>
 309                 public virtual string BuildUrl(UrlInfo current, string controller, string action, IDictionary queryStringParams)
 310                 {
 311                         Hashtable parameters = new Hashtable();
 312                         parameters["controller"] = controller;
 313                         parameters["action"] = action;
 314                         parameters["querystring"] = queryStringParams;
 315                         return BuildUrl(current, parameters);
 316                 }
 317
 318                 /// <summary>
 319                 /// Builds an URL using the controller name, action name, and a querystring name value collection.
 320                 /// </summary>
 321                 /// <param name="current">The current Url information.</param>
 322                 /// <param name="controller">The controller.</param>
 323                 /// <param name="action">The action.</param>
 324                 /// <param name="queryStringParams">The query string params.</param>
 325                 /// <returns></returns>
 326                 public virtual string BuildUrl(UrlInfo current, string controller, string action, NameValueCollection queryStringParams)
 327                 {
 328                         Hashtable parameters = new Hashtable();
 329                         parameters["controller"] = controller;
 330                         parameters["action"] = action;
 331                         parameters["querystring"] = queryStringParams;
 332                         return BuildUrl(current, parameters);
 333                 }
 334
 335                 /// <summary>
 336                 /// Builds an URL using the area name, controller name and action name.
 337                 /// </summary>
 338                 /// <param name="current">The current Url information.</param>
 339                 /// <param name="area">The area.</param>
 340                 /// <param name="controller">The controller.</param>
 341                 /// <param name="action">The action.</param>
 342                 /// <returns></returns>
 343                 public virtual string BuildUrl(UrlInfo current, string area, string controller, string action)
 344                 {
 345                         Hashtable parameters = new Hashtable();
 346                         parameters["area"] = area;
 347                         parameters["controller"] = controller;
 348                         parameters["action"] = action;
 349                         return BuildUrl(current, parameters);
 350                 }
 351
 352                 /// <summary>
 353                 /// Builds an URL using the area name, controller name, action name, and a querystring dictionary.
 354                 /// </summary>
 355                 /// <param name="current">The current Url information.</param>
 356                 /// <param name="area">The area.</param>
 357                 /// <param name="controller">The controller.</param>
 358                 /// <param name="action">The action.</param>
 359                 /// <param name="queryStringParams">The query string params.</param>
 360                 /// <returns></returns>
 361                 public virtual string BuildUrl(UrlInfo current, string area, string controller, string action, IDictionary queryStringParams)
 362                 {
 363                         Hashtable parameters = new Hashtable();
 364                         parameters["area"] = area;
 365                         parameters["controller"] = controller;
 366                         parameters["action"] = action;
 367                         parameters["querystring"] = queryStringParams;
 368                         return BuildUrl(current, parameters);
 369                 }
 370
 371                 /// <summary>
 372                 /// Builds an URL using the area name, controller name, action name, and a querystring name value collection.
 373                 /// </summary>
 374                 /// <param name="current">The current Url information.</param>
 375                 /// <param name="area">The area.</param>
 376                 /// <param name="controller">The controller.</param>
 377                 /// <param name="action">The action.</param>
 378                 /// <param name="queryStringParams">The query string params.</param>
 379                 /// <returns></returns>
 380                 public virtual string BuildUrl(UrlInfo current, string area, string controller, string action,
 381                                                NameValueCollection queryStringParams)
 382                 {
 383                         Hashtable parameters = new Hashtable();
 384                         parameters["area"] = area;
 385                         parameters["controller"] = controller;
 386                         parameters["action"] = action;
 387                         parameters["querystring"] = queryStringParams;
 388                         return BuildUrl(current, parameters);
 389                 }
 390
 391                 #endregion
 392
 393                 /// <summary>
 394                 /// Internals the build URL.
 395                 /// </summary>
 396                 /// <param name="area">The area.</param>
 397                 /// <param name="controller">The controller.</param>
 398                 /// <param name="action">The action.</param>
 399                 /// <param name="protocol">The protocol.</param>
 400                 /// <param name="port">The port.</param>
 401                 /// <param name="domain">The domain.</param>
 402                 /// <param name="subdomain">The subdomain.</param>
 403                 /// <param name="appVirtualDir">The app virtual dir.</param>
 404                 /// <param name="extension">The extension.</param>
 405                 /// <param name="absolutePath">if set to <c>true</c> [absolute path].</param>
 406                 /// <param name="applySubdomain">if set to <c>true</c> [apply subdomain].</param>
 407                 /// <param name="suffix">The suffix.</param>
 408                 /// <returns></returns>
 409                 protected virtual string InternalBuildUrl(string area, string controller, string action, string protocol,
 410                                                           string port, string domain, string subdomain, string appVirtualDir,
 411                                                           string extension,
 412                                                           bool absolutePath, bool applySubdomain, string suffix)
 413                 {
 414                         return
 415                                 InternalBuildUrl(area, controller, action, protocol, port, domain, subdomain, appVirtualDir, extension, absolutePath,
 416                                                  applySubdomain, suffix, null, null).BuildPath();
 417                 }
 418
 419                 /// <summary>
 420                 /// Internals the build URL.
 421                 /// </summary>
 422                 /// <param name="area">The area.</param>
 423                 /// <param name="controller">The controller.</param>
 424                 /// <param name="action">The action.</param>
 425                 /// <param name="protocol">The protocol.</param>
 426                 /// <param name="port">The port.</param>
 427                 /// <param name="domain">The domain.</param>
 428                 /// <param name="subdomain">The subdomain.</param>
 429                 /// <param name="appVirtualDir">The app virtual dir.</param>
 430                 /// <param name="extension">The extension.</param>
 431                 /// <param name="absolutePath">if set to <c>true</c> [absolute path].</param>
 432                 /// <param name="applySubdomain">if set to <c>true</c> [apply subdomain].</param>
 433                 /// <param name="suffix">The suffix.</param>
 434                 /// <param name="basePath">The base path.</param>
 435                 /// <param name="pathInfo">Path info</param>
 436                 /// <returns></returns>
 437                 protected virtual UrlPartsBuilder InternalBuildUrl(string area, string controller, string action, string protocol,
 438                                                                    string port, string domain, string subdomain, string appVirtualDir,
 439                                                                    string extension,
 440                                                                    bool absolutePath, bool applySubdomain, string suffix,
 441                                                                    string basePath,
 442                                                                    string pathInfo)
 443                 {
 444                         if (area == null) throw new ArgumentNullException("area");
 445                         if (controller == null) throw new ArgumentNullException("controller");
 446                         if (action == null) throw new ArgumentNullException("action");
 447                         if (appVirtualDir == null) throw new ArgumentNullException("appVirtualDir");
 448
 449                         string path;
 450
 451                         if (basePath != null)
 452                         {
 453                                 path = InternalBuildUrlUsingBasePath(action, area, basePath, controller);
 454                         }
 455                         else
 456                         {
 457                                 path = InternalBuildUsingAppVirtualDir(absolutePath, action, applySubdomain, appVirtualDir, area, controller, domain, port, protocol, subdomain);
 458                         }
 459
 460                         if (useExtensions)
 461                         {
 462                                 path += "." + extension;
 463                         }
 464
 465                         UrlPartsBuilder urlBuilder = new UrlPartsBuilder(path);
 466
 467                         urlBuilder.PathInfoDict.Parse(pathInfo);
 468
 469                         if (!string.IsNullOrEmpty(suffix))
 470                         {
 471                                 urlBuilder.SetQueryString(suffix);
 472                         }
 473
 474                         return urlBuilder;
 475                 }
 476
 477                 /// <summary>
 478                 /// Internals the build route URL.
 479                 /// </summary>
 480                 /// <param name="hostname">The hostname.</param>
 481                 /// <param name="virtualDir">The virtual dir.</param>
 482                 /// <param name="name">The name.</param>
 483                 /// <param name="routeParams">The route params.</param>
 484                 /// <param name="encode">if set to <c>true</c> [encode].</param>
 485                 /// <returns></returns>
 486                 protected virtual UrlPartsBuilder InternalBuildRouteUrl(string hostname, string virtualDir,
 487                                                                         string name, object routeParams, bool encode)
 488                 {
 489                         IDictionary parameters;
 490
 491                         if (routeParams != null)
 492                         {
 493                                 if (typeof(IDictionary).IsAssignableFrom(routeParams.GetType()))
 494                                 {
 495                                         parameters = (IDictionary) routeParams;
 496                                 }
 497                                 else
 498                                 {
 499                                         parameters = new ReflectionBasedDictionaryAdapter(routeParams);
 500                                 }
 501                         }
 502                         else
 503                         {
 504                                 parameters = new Hashtable();
 505                         }
 506
 507                         String url = routingEng.CreateUrl(name, hostname, virtualDir, parameters);
 508
 509                         // TODO: should encode?
 510
 511                         return new UrlPartsBuilder(url);
 512                 }
 513
 514                 /// <summary>
 515                 /// Internals the build using app virtual dir.
 516                 /// </summary>
 517                 /// <param name="absolutePath">if set to <c>true</c> [absolute path].</param>
 518                 /// <param name="action">The action.</param>
 519                 /// <param name="applySubdomain">if set to <c>true</c> [apply subdomain].</param>
 520                 /// <param name="appVirtualDir">The app virtual dir.</param>
 521                 /// <param name="area">The area.</param>
 522                 /// <param name="controller">The controller.</param>
 523                 /// <param name="domain">The domain.</param>
 524                 /// <param name="port">The port.</param>
 525                 /// <param name="protocol">The protocol.</param>
 526                 /// <param name="subdomain">The subdomain.</param>
 527                 /// <returns></returns>
 528                 protected static string InternalBuildUsingAppVirtualDir(bool absolutePath, string action,
 529                                                                         bool applySubdomain, string appVirtualDir,
 530                                                                         string area, string controller,
 531                                                                         string domain, string port, string protocol, string subdomain)
 532                 {
 533                         string path;
 534
 535                         if (appVirtualDir.Length > 1 && !(appVirtualDir[0] == '/'))
 536                         {
 537                                 appVirtualDir = "/" + appVirtualDir;
 538                         }
 539
 540                         if (area != String.Empty)
 541                         {
 542                                 path = appVirtualDir + "/" + area + "/" + controller + "/" + action;
 543                         }
 544                         else
 545                         {
 546                                 path = appVirtualDir + "/" + controller + "/" + action;
 547                         }
 548
 549                         if (absolutePath)
 550                         {
 551                                 string url;
 552
 553                                 if (applySubdomain)
 554                                 {
 555                                         url = protocol + "://" + subdomain + domain;
 556                                 }
 557                                 else
 558                                 {
 559                                         url = protocol + "://" + domain;
 560                                 }
 561
 562                                 if (port != "80")
 563                                 {
 564                                         url += ":" + port;
 565                                 }
 566
 567                                 path = url + path;
 568                         }
 569
 570                         return path;
 571                 }
 572
 573                 /// <summary>
 574                 /// Internals the build URL using base path.
 575                 /// </summary>
 576                 /// <param name="action">The action.</param>
 577                 /// <param name="area">The area.</param>
 578                 /// <param name="basePath">The base path.</param>
 579                 /// <param name="controller">The controller.</param>
 580                 /// <returns></returns>
 581                 protected static string InternalBuildUrlUsingBasePath(string action, string area, string basePath, string controller)
 582                 {
 583                         string path;
 584
 585                         basePath = basePath[basePath.Length - 1] == '/' ? basePath.Substring(0, basePath.Length - 1) : basePath;
 586
 587                         if (basePath.EndsWith(area))
 588                         {
 589                                 path = basePath + "/" + controller + "/" + action;
 590                         }
 591                         else
 592                         {
 593                                 path = basePath + "/" + area + "/" + controller + "/" + action;
 594                         }
 595
 596                         return path;
 597                 }
 598         }
 599 }