Пример #1
0
 /// <summary>
 /// Appends the path info.
 /// </summary>
 /// <param name="parts">The parts.</param>
 /// <param name="parameters">The parameters.</param>
 protected virtual void AppendPathInfo(UrlParts parts, UrlBuilderParameters parameters)
 {
     if (!string.IsNullOrEmpty(parameters.PathInfo))
     {
         parts.PathInfoDict.Parse(parameters.PathInfo);
     }
 }
Пример #2
0
        /// <summary>
        /// Builds the URL using the current url as contextual information and the specified parameters.
        /// <para>
        /// Common parameters includes area, controller and action. See <see cref="UrlBuilderParameters"/>
        /// for more information regarding the parameters.
        /// </para>
        /// </summary>
        /// <param name="current">The current Url information.</param>
        /// <param name="parameters">The parameters.</param>
        /// <param name="routeParameters">The route parameters.</param>
        /// <returns></returns>
        public virtual UrlParts CreateUrlPartsBuilder(UrlInfo current, IDictionary parameters, IDictionary routeParameters)
        {
            AssertArguments(current, parameters);

            var typedParams = UrlBuilderParameters.From(parameters, routeParameters);

            return(CreateUrlPartsBuilder(current, parameters, ConvertRouteParams(typedParams.RouteParameters)));
        }
Пример #3
0
        /// <summary>
        /// Builds the URL using the current url as contextual information and the specified parameters.
        /// <para>
        /// Common parameters includes area, controller and action. See <see cref="UrlBuilderParameters"/>
        /// for more information regarding the parameters.
        /// </para>
        /// </summary>
        /// <param name="current">The current Url information.</param>
        /// <param name="parameters">The parameters.</param>
        /// <param name="routeParameters">The route parameters.</param>
        /// <returns></returns>
        public virtual string BuildUrl(UrlInfo current, IDictionary parameters, IDictionary routeParameters)
        {
            AssertArguments(current, parameters);

            var typedParams = UrlBuilderParameters.From(parameters, routeParameters);

            return(BuildUrl(current, typedParams, ConvertRouteParams(typedParams.RouteParameters)));
        }
Пример #4
0
        /// <summary>
        /// Applies the base path or absolute path if necessary.
        /// </summary>
        /// <param name="appVirtualDir">The app virtual dir.</param>
        /// <param name="area">The area.</param>
        /// <param name="current">The current.</param>
        /// <param name="parameters">The parameters.</param>
        /// <param name="path">The path.</param>
        /// <returns></returns>
        protected virtual string ApplyBasePathOrAbsolutePathIfNecessary(string appVirtualDir, string area, UrlInfo current,
                                                                        UrlBuilderParameters parameters, string path)
        {
            var createAbsolutePath = parameters.CreateAbsolutePath;
            var basePath           = parameters.BasePath;

            if (!string.IsNullOrEmpty(basePath))
            {
                basePath = basePath[basePath.Length - 1] == '/' ? basePath.Substring(0, basePath.Length - 1) : basePath;

                if (basePath.EndsWith(area, StringComparison.InvariantCultureIgnoreCase))
                {
                    path = basePath;
                }
                else
                {
                    path = basePath + "/" + area;
                }
            }
            else if (createAbsolutePath)
            {
                var domain    = parameters.Domain ?? current.Domain;
                var subdomain = parameters.Subdomain ?? current.Subdomain;
                var protocol  = parameters.Protocol ?? current.Protocol;
                var port      = parameters.Port == 0 ? current.Port : parameters.Port;

                var includePort =
                    (protocol == "http" && port != 80) ||
                    (protocol == "https" && port != 443);

                path = protocol + "://";

                if (!string.IsNullOrEmpty(subdomain))
                {
                    path += subdomain + "." + domain;
                }
                else
                {
                    path += domain;
                }

                if (includePort)
                {
                    path += ":" + port;
                }

                path += ComputeStandardBasePath(appVirtualDir, area);
            }

            return(path);
        }
Пример #5
0
        /// <summary>
        /// Builds the URL using the current url as contextual information and the specified parameters.
        /// <para>
        /// Common parameters includes area, controller and action. See <see cref="UrlBuilderParameters"/>
        /// for more information regarding the parameters.
        /// </para>
        /// </summary>
        /// <param name="current">The current Url information.</param>
        /// <param name="parameters">The parameters.</param>
        /// <param name="routeParameters">The route parameters.</param>
        /// <returns></returns>
        public virtual string BuildUrl(UrlInfo current, UrlBuilderParameters parameters, IDictionary routeParameters)
        {
            AssertArguments(current, parameters);

            var encodeForLink = parameters.EncodeForLink;

            var url = CreateUrlPartsBuilder(current, parameters, routeParameters);

            if (encodeForLink)
            {
                return(url.BuildPathForLink());
            }

            return(url.BuildPath());
        }
Пример #6
0
        /// <summary>
        /// Appends the query string.
        /// </summary>
        /// <param name="parts">The parts.</param>
        /// <param name="parameters">The parameters.</param>
        protected virtual void AppendQueryString(UrlParts parts, UrlBuilderParameters parameters)
        {
            var queryString = parameters.QueryString;

            var suffix = string.Empty;

            if (queryString != null)
            {
                if (queryString is IDictionary)
                {
                    var qsDictionary = (IDictionary)queryString;

                    suffix = CommonUtils.BuildQueryString(serverUtil, qsDictionary, false);
                }
                else if (queryString is NameValueCollection)
                {
                    suffix = CommonUtils.BuildQueryString(serverUtil, (NameValueCollection)queryString, false);
                }
                else if (queryString is string && ((string)queryString).Length > 0)
                {
                    var pairs = queryString.ToString().Split('&');

                    suffix = string.Empty;

                    foreach (var pair in pairs)
                    {
                        var keyvalues = pair.Split(new[] { '=' }, 2);

                        if (keyvalues.Length < 2)
                        {
                            continue;
                        }

                        if (suffix.Length != 0)
                        {
                            suffix += "&";
                        }

                        suffix += serverUtil.UrlEncode(keyvalues[0]) + "=" + serverUtil.UrlEncode(keyvalues[1]);
                    }
                }
            }

            if (suffix != string.Empty)
            {
                parts.SetQueryString(suffix);
            }
        }
Пример #7
0
        /// <summary>
        /// Tries the create URL using registered routes.
        /// </summary>
        /// <param name="domain">The domain.</param>
        /// <param name="parameters">The parameters.</param>
        /// <param name="appVirtualDir">The app virtual dir.</param>
        /// <param name="routeParameters">The route parameters.</param>
        /// <returns></returns>
        protected UrlParts TryCreateUrlUsingRegisteredRoutes(string domain, UrlBuilderParameters parameters,
                                                             string appVirtualDir,
                                                             IDictionary routeParameters)
        {
            if (routingEng != null && !routingEng.IsEmpty)
            {
                // We take was was explicitly set (we do not inherit those from the context)
                routeParameters["area"]       = parameters.Area ?? routeParameters["area"];
                routeParameters["controller"] = parameters.Controller ?? routeParameters["controller"];
                routeParameters["action"]     = parameters.Action ?? routeParameters["action"];

                if (parameters.UseCurrentRouteParams)
                {
                    if (parameters.RouteMatch == null)
                    {
                        throw new InvalidOperationException("Error creating URL. 'UseCurrentRouteParams' was set, but routematch is null.");
                    }

                    CommonUtils.MergeOptions(routeParameters, parameters.RouteMatch.Parameters);
                }

                string url;

                if (parameters.RouteName != null)
                {
                    url = routingEng.CreateUrl(parameters.RouteName, routeParameters);
                }
                //If we want to UseCurrentRouteParams and the current RouteMatch has a name than we should create the url using the current route name
                else if (parameters.UseCurrentRouteParams && parameters.RouteMatch != null && !String.IsNullOrEmpty(parameters.RouteMatch.Name))
                {
                    url = routingEng.CreateUrl(parameters.RouteMatch.Name, routeParameters);
                }
                else
                {
                    url = routingEng.CreateUrl(routeParameters);
                }

                if (url != null)
                {
                    return(new UrlParts(serverUtil, url));
                }
            }

            return(null);
        }
Пример #8
0
        /// <summary>
        /// Builds the URL using the current url as contextual information and the specified parameters.
        /// <para>
        /// Common parameters includes area, controller and action. See <see cref="UrlBuilderParameters"/>
        /// for more information regarding the parameters.
        /// </para>
        /// </summary>
        /// <param name="current">The current Url information.</param>
        /// <param name="parameters">The parameters.</param>
        /// <param name="routeParameters">The route parameters.</param>
        /// <returns></returns>
        public virtual UrlParts CreateUrlPartsBuilder(UrlInfo current, UrlBuilderParameters parameters, IDictionary routeParameters)
        {
            AssertArguments(current, parameters);

            var appVirtualDir = current.AppVirtualDir;

            var area       = parameters.Area ?? current.Area;
            var controller = parameters.Controller ?? current.Controller;
            var action     = parameters.Action ?? current.Action;

            if (appVirtualDir.Length > 0 && !(appVirtualDir[0] == '/'))
            {
                appVirtualDir = "/" + appVirtualDir;
            }

            var path = ComputeStandardBasePath(appVirtualDir, area);

            path = ApplyBasePathOrAbsolutePathIfNecessary(appVirtualDir, area, current, parameters, path);

            var parts = TryCreateUrlUsingRegisteredRoutes(current.Domain, parameters, appVirtualDir, routeParameters);

            if (parts == null)
            {
                parts = new UrlParts(serverUtil, path, controller, action + (useExtensions ? SafeExt(current.Extension) : ""));
                AppendPathInfo(parts, parameters);
            }
            else
            {
                if (parameters.CreateAbsolutePath)
                {
                    parts.InsertFrontPath(path);
                }
                else if (appVirtualDir != "/")
                {
                    parts.InsertFrontPath(appVirtualDir);
                }
            }

            AppendQueryString(parts, parameters);

            return(parts);
        }
		public void UseCurrentRouteParamsShouldBeHonoredRegardlessOfTheRoutingOrder()
		{
			var urlInfo = new UrlInfo("Services", "ModifyServiceWizard", "Step1", String.Empty, String.Empty);

			var parameters = new UrlBuilderParameters
			{
				RouteMatch = new RouteMatch
				{
					Name = "ServiceWizardModify"
				}
			};
			parameters.RouteMatch.AddNamed("serviceArea", "Marketing");
			parameters.RouteMatch.AddNamed("action", "Step1");
			parameters.RouteMatch.AddNamed("controller", "ModifyServiceWizard");
			parameters.RouteMatch.AddNamed("area", "Services");
			parameters.UseCurrentRouteParams = true;

			IDictionary routeParameters = new HybridDictionary { { "action", "Step2" } };

			IRoutingEngine routingEngine = new StubRoutingEngine();
			routingEngine.Add(
				new PatternRoute("ServiceWizardCreate", "/Services/<serviceArea>/AddWizard/[action]")
					.DefaultForController().Is("CreateServiceWizard")
					.DefaultForArea().Is("Services")
					.DefaultForAction().Is("start")
				);

			routingEngine.Add(
				new PatternRoute("ServiceWizardModify", "/Services/<serviceArea>/ModifyWizard/[action]")
					.DefaultForController().Is("ModifyServiceWizard")
					.DefaultForArea().Is("Services")
					.DefaultForAction().Is("start")
				);
			urlBuilder.RoutingEngine = routingEngine;

			Assert.AreEqual("/Services/Marketing/ModifyWizard/Step2",
			                urlBuilder.BuildUrl(urlInfo, parameters, routeParameters));
		}
		public void RouteParametersShouldBePersistedDuringCreateUrlPartsWhenNoneSpecifiedInParameters()
		{
			var urlInfo = new UrlInfo("i", "shouldbe", "overridden", "/", ".castle");

			var parameters = new UrlBuilderParameters();//empty collection
			IDictionary routeParameters = new HybridDictionary
			{
				{ "area", "routearea" }, 
				{ "controller", "routecontroller" }, 
				{ "action", "routeaction" }
			};

			IRoutingEngine routingEngine = new StubRoutingEngine();
			routingEngine.Add(new PatternRoute("default", "<area>/<controller>/<action>"));//keep routing engine from being empty
			urlBuilder.RoutingEngine = routingEngine;

			Assert.AreEqual("/routearea/routecontroller/routeaction",
				urlBuilder.BuildUrl(urlInfo, parameters, routeParameters));

		}
		public void UseAbsPathWithWWW()
		{
			var tokenizer = new DefaultUrlTokenizer();
			var urlinfo = tokenizer.TokenizeUrl("/area/home/index.castle", null,
								  new Uri("http://www.castleproject.org"), true, string.Empty);


			var parameters = new UrlBuilderParameters("test", "action") { CreateAbsolutePath = true };

			Assert.AreEqual("http://www.castleproject.org/area/test/action.castle",
				urlBuilder.BuildUrl(urlinfo, parameters));
		}
Пример #12
0
 private static NavItem Item(IEngineContext context, string caption, string controller, string action)
 {
     var parameters = new UrlBuilderParameters(controller, action);
     return new NavItem
                {
                    Caption = caption,
                    Url = context.Services.UrlBuilder.BuildUrl(context.UrlInfo, parameters)
                };
 }
Пример #13
0
        /// <summary>
        /// Builds the URL using the current url as contextual information and the specified parameters.
        /// <para>
        /// Common parameters includes area, controller and action. See <see cref="UrlBuilderParameters"/>
        /// for more information regarding the parameters.
        /// </para>
        /// </summary>
        /// <param name="current">The current Url information.</param>
        /// <param name="parameters">The parameters.</param>
        /// <returns></returns>
        public virtual UrlParts CreateUrlPartsBuilder(UrlInfo current, UrlBuilderParameters parameters)
        {
            AssertArguments(current, parameters);

            return(CreateUrlPartsBuilder(current, parameters, ConvertRouteParams(parameters.RouteParameters)));
        }
Пример #14
0
        /// <summary>
        /// Builds the URL using the current url as contextual information and the specified parameters.
        /// <para>
        /// Common parameters includes area, controller and action. See <see cref="UrlBuilderParameters"/>
        /// for more information regarding the parameters.
        /// </para>
        /// </summary>
        /// <param name="current">The current Url information.</param>
        /// <param name="parameters">The parameters.</param>
        /// <returns></returns>
        public virtual string BuildUrl(UrlInfo current, UrlBuilderParameters parameters)
        {
            AssertArguments(current, parameters);

            return(BuildUrl(current, parameters, ConvertRouteParams(parameters.RouteParameters)));
        }
		public void If_Route_Name_Is_Specified_It_Should_Be_Used_Even_If_UseCurrentRouteParams_Is_True()
		{
			var urlInfo = new UrlInfo("", "Car", "View", String.Empty, String.Empty);

			var parameters = new UrlBuilderParameters
			{
				RouteMatch = new RouteMatch
			{
				Name = "CarRoute"
			}
			};
			parameters.RouteMatch.AddNamed("carName", "Ford");
			parameters.RouteMatch.AddNamed("action", "View");
			parameters.RouteMatch.AddNamed("controller", "Car");
			parameters.UseCurrentRouteParams = true;
			parameters.RouteName = "CarAddOptionWizard";

			IRoutingEngine routingEngine = new StubRoutingEngine();
			routingEngine.Add(
				new PatternRoute("CarRoute", "/Car/<carName>/[action]")
					.DefaultForController().Is("Car")
					.DefaultForAction().Is("VIew")
				);

			routingEngine.Add(
				new PatternRoute("CarAddOptionWizard", "/Car/<carName>/AddOption/[action]")
					.DefaultForController().Is("CarAddOptionWizard")
					.DefaultForAction().Is("start")
				);
			urlBuilder.RoutingEngine = routingEngine;

			Assert.AreEqual("/Car/Ford/AddOption",
				urlBuilder.BuildUrl(urlInfo, parameters));
		}
		public void ShouldWorkForSingleLetterAppVirtualDir()
		{
			var tokenizer = new DefaultUrlTokenizer();
			var urlinfo = tokenizer.TokenizeUrl("/v/area/controller/action.castle", null,
								  new Uri("http://www.castleproject.org/v/area/controller/action.castle"), true, "/v");

			var parameters = new UrlBuilderParameters();

			Assert.AreEqual("/v/area/controller/action.castle", urlBuilder.BuildUrl(urlinfo, parameters));
		}
		protected virtual void InitializePropertyBagForCulture( CultureInfo culture )
		{
			UrlBuilderParameters parameters = new UrlBuilderParameters( "Culture", "SetCulture" );
			parameters.QueryString = DictHelper.CreateN( "cultureCode", culture.Name ).N( "backUrl", EngineContext.Request.Url );

			bool isCurrent = CultureInfo.CurrentCulture.Name == culture.Name ||
								( !CultureInfo.CurrentCulture.IsNeutralCulture &&
									CultureInfo.CurrentCulture.Parent.Name.Equals( culture.Name ) );

			PropertyBag[ "CultureCulture" ] = culture;
			PropertyBag[ "IsCurrent" ] = isCurrent;
			PropertyBag[ "SelectionUrl" ] = EngineContext.Services.UrlBuilder.BuildUrl( EngineContext.UrlInfo, parameters );
			PropertyBag[ "FlagImageUrl" ] = _ResourceHelper.GetImageResourceUrl( GetFlagResourceName( culture ) );
		}