/// <summary>
/// Tries to resolve the target redirect url by using the routing rules registered.
/// </summary>
/// <param name="area">The area the target controller belongs to.</param>
/// <param name="controller">The controller name to be redirected to.</param>
/// <param name="action">The desired action on the target controller.</param>
/// <param name="useCurrentRouteParams">if set to <c>true</c> the current request matching route rules will be used.</param>
public void RedirectUsingRoute(string area, string controller, string action, bool useCurrentRouteParams)
{
var @params = new UrlBuilderParameters(area, controller, action).
SetRouteMatch(useCurrentRouteParams, routeMatch);
RedirectToUrl(urlBuilder.BuildUrl(currentUrl, @params), false);
}
private void ActionRender(IDictionary parameters, TextWriter writer)
{
UrlBuilderParameters urlBuilderParameters = UrlBuilderParameters.From(parameters);
var urlInfo = new UrlInfo(urlBuilderParameters.Area, urlBuilderParameters.Controller, urlBuilderParameters.Action);
IController controller = Context.Services.ControllerFactory.CreateController(urlBuilderParameters.Area,
urlBuilderParameters.Controller);
IControllerContext controllerContext = Context.Services.ControllerContextFactory.Create(urlBuilderParameters.Area,
urlBuilderParameters.
Controller,
urlBuilderParameters.Action,
Context.Services.
ControllerDescriptorProvider
.BuildDescriptor(
controller));
IEngineContext engineContext = Context.Services.EngineContextFactory.Create(container, urlInfo,
Context.UnderlyingContext,
new RouteMatch());
engineContext.CurrentController = controller;
engineContext.CurrentControllerContext = controllerContext;
var childMonoRailHttpHandler = new ChildMonoRailHttpHandler(engineContext, controller, controllerContext);
Context.UnderlyingContext.Server.Execute(new HttpHandlerWrapper(childMonoRailHttpHandler), writer, true);
}
string BuildUrl(IDictionary parameters)
{
var urlparams = UrlBuilderParameters.From(parameters).SetRouteMatch(ControllerContext.RouteMatch);
urlparams.EncodeForLink = true;
return(UrlBuilder.BuildUrl(CurrentUrl, urlparams));
}
/// <summary>
/// Redirects using a named route.
/// The name must exists otherwise a <see cref="MonoRailException"/> will be thrown.
/// </summary>
/// <param name="routeName">Route name.</param>
public void RedirectUsingNamedRoute(string routeName)
{
var @params = new UrlBuilderParameters {
RouteName = routeName
};
RedirectToUrl(urlBuilder.BuildUrl(currentUrl, @params), false);
}
/// <summary>
/// Outputs a path constructed using the specified parameters.
/// </summary>
///
/// <seealso cref="DefaultUrlBuilder.BuildUrl(UrlInfo,IDictionary)"/>
///
/// <example>
/// The following code uses nvelocity syntax:
///
/// <code>
/// $url.for("%{action='Save'}")
/// </code>
///
/// <para>outputs</para>
///
/// <code>/ControllerNameFromContext/Save.extension_configured</code>
///
/// <code>
/// $url.for("%{action='Edit',querystring='id=1'}")
/// </code>
///
/// <para>outputs</para>
///
/// <code>/ControllerNameFromContext/Edit.extension_configured?id=1</code>
/// </example>
///
/// <param name="parameters">The parameters.</param>
/// <returns></returns>
public string For(IDictionary parameters)
{
SetEncodeDefault(parameters);
var urlParams = UrlBuilderParameters.From(parameters).
SetRouteMatch(ControllerContext.RouteMatch);
return(urlBuilder.BuildUrl(currentUrl, urlParams));
}
/// <summary>
/// Tries to resolve the target redirect url by using the routing rules registered.
/// </summary>
/// <param name="area">The area the target controller belongs to.</param>
/// <param name="controller">The controller name to be redirected to.</param>
/// <param name="action">The desired action on the target controller.</param>
/// <param name="routeParameters">The routing rule parameters.</param>
public void RedirectUsingRoute(string area, string controller, string action, object routeParameters)
{
var @params = new UrlBuilderParameters(area, controller, action)
{
RouteParameters = routeParameters
};
RedirectToUrl(urlBuilder.BuildUrl(currentUrl, @params), false);
}
private void InternalRedirectToStep(IEngineContext engineContext, int stepIndex, String step,
IDictionary queryStringParameters)
{
WizardUtils.RegisterCurrentStepInfo(engineContext, wizardParentController, wizardcontrollerContext, stepIndex, step);
// Does this support areas?
var urlBuilder = engineContext.Services.GetService <IUrlBuilder>();
if (queryStringParameters != null && queryStringParameters.Count != 0)
{
if (WizardController.UseCurrentRouteForRedirects)
{
var dictionary = new Dictionary <string, string>(wizardcontrollerContext.RouteMatch.Parameters);
dictionary["action"] = step;
var parameters = UrlBuilderParameters.From(queryStringParameters, dictionary);
RedirectToUrl(urlBuilder.BuildUrl(engineContext.UrlInfo, parameters));
}
else
{
Redirect(WizardControllerContext.AreaName, wizardcontrollerContext.Name, step, queryStringParameters);
}
}
else if (Context.Request.QueryString.HasKeys())
{
// We need to preserve any attribute from the QueryString
// for example in case the url has an Id
if (WizardController.UseCurrentRouteForRedirects)
{
var queryParameters = new Dictionary <string, string>();
foreach (var key in Query.AllKeys)
{
queryParameters.Add(key, Query[key]);
}
var parameters = UrlBuilderParameters.From(queryParameters,
wizardcontrollerContext.RouteMatch.Parameters);
RedirectToUrl(urlBuilder.BuildUrl(engineContext.UrlInfo, parameters));
}
else
{
Redirect(WizardControllerContext.AreaName, wizardcontrollerContext.Name, step, Query);
}
}
else
{
if (WizardController.UseCurrentRouteForRedirects)
{
RedirectUsingRoute(step, true);
}
else
{
Redirect(WizardControllerContext.AreaName, wizardcontrollerContext.Name, step);
}
}
}
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));
}
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)
});
}
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));
}
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));
}
protected override string CreateUrlForPage(int pageIndex)
{
var old = Querystring[PageParamName];
Querystring[PageParamName] = pageIndex;
var dict = DictHelper.Create();
dict.Add("area", string.IsNullOrEmpty(Area) ? EngineContext.UrlInfo.Area : Area);
dict.Add("controller", string.IsNullOrEmpty(Controller) ? EngineContext.UrlInfo.Controller : Controller);
dict.Add("action", string.IsNullOrEmpty(Action) ? EngineContext.UrlInfo.Action : Action);
dict.Add("querystring", Querystring);
var urlparams = UrlBuilderParameters.From(dict).SetRouteMatch(EngineContext.CurrentControllerContext.RouteMatch);
urlparams.EncodeForLink = true;
var url = EngineContext.Services.UrlBuilder.BuildUrl(EngineContext.UrlInfo, urlparams);
Querystring[PageParamName] = old;
return(url);
}
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 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));
}
/// <summary>
/// Tries to resolve the target redirect url by using the routing rules registered.
/// </summary>
/// <param name="area">The area the target controller belongs to.</param>
/// <param name="controller">The controller name to be redirected to.</param>
/// <param name="action">The desired action on the target controller.</param>
/// <param name="routeParameters">The routing rule parameters.</param>
public void RedirectUsingRoute(string area, string controller, string action, object routeParameters)
{
var @params = new UrlBuilderParameters(area, controller, action)
{
RouteParameters = routeParameters
};
RedirectToUrl(urlBuilder.BuildUrl(currentUrl, @params), false);
}
/// <summary>
/// Tries to resolve the target redirect url by using the routing rules registered.
/// </summary>
/// <param name="area">The area the target controller belongs to.</param>
/// <param name="controller">The controller name to be redirected to.</param>
/// <param name="action">The desired action on the target controller.</param>
/// <param name="useCurrentRouteParams">if set to <c>true</c> the current request matching route rules will be used.</param>
public void RedirectUsingRoute(string area, string controller, string action, bool useCurrentRouteParams)
{
var @params = new UrlBuilderParameters(area, controller, action).
SetRouteMatch(useCurrentRouteParams, routeMatch);
RedirectToUrl(urlBuilder.BuildUrl(currentUrl, @params), false);
}
/// <summary>
/// Redirects using a named route.
/// The name must exists otherwise a <see cref="MonoRailException"/> will be thrown.
/// </summary>
/// <param name="routeName">Route name.</param>
/// <param name="routeParameters">The route parameters.</param>
public void RedirectUsingNamedRoute(string routeName, IDictionary routeParameters)
{
var @params = new UrlBuilderParameters
{
RouteName = routeName,
RouteParameters = routeParameters
};
RedirectToUrl(urlBuilder.BuildUrl(currentUrl, @params), false);
}
/// <summary>
/// Tries to resolve the target redirect url by using the routing rules registered.
/// </summary>
/// <param name="area">The area the target controller belongs to.</param>
/// <param name="controller">The controller name to be redirected to.</param>
/// <param name="action">The desired action on the target controller.</param>
/// <param name="routeParameters">The routing rule parameters.</param>
public void RedirectUsingRoute(string area, string controller, string action, IDictionary routeParameters)
{
UrlBuilderParameters @params = new UrlBuilderParameters(area, controller, action);
@params.RouteParameters = routeParameters;
RedirectToUrl(urlBuilder.BuildUrl(currentUrl, @params), false);
}
/// <summary>
/// Redirects using a named route.
/// The name must exists otherwise a <see cref="MonoRailException"/> will be thrown.
/// </summary>
/// <param name="routeName">Route name.</param>
/// <param name="routeParameters">The route parameters.</param>
public void RedirectUsingNamedRoute(string routeName, object routeParameters)
{
UrlBuilderParameters @params = new UrlBuilderParameters();
@params.RouteName = routeName;
@params.RouteParameters = routeParameters;
RedirectToUrl(urlBuilder.BuildUrl(currentUrl, @params), false);
}
