/// <summary>
/// Gets the permanent URL for the <see cref="WxeFunction"/> of the specified <paramref name="functionType"/>
/// and using the <paramref name="urlParameters"/>.
/// </summary>
/// <include file='..\doc\include\ExecutionEngine\WxeContext.xml' path='WxeContext/GetPermanentUrl/param[@name="functionType" or @name="urlParameters" or @name="useParentPermanentUrl"]' />
public string GetPermanentUrl(Type functionType, NameValueCollection urlParameters, bool useParentPermanentUrl)
{
ArgumentUtility.CheckNotNull("urlParameters", urlParameters);
string permanentUrl = WxeContext.GetPermanentUrl(_httpContext, functionType, urlParameters, true);
if (useParentPermanentUrl)
{
if (urlParameters[WxeHandler.Parameters.ReturnUrl] != null)
{
throw new ArgumentException("The 'urlParameters' collection must not contain a 'ReturnUrl' parameter when creating a parent permanent URL.", "urlParameters");
}
int maxLength = Configuration.WebConfiguration.Current.ExecutionEngine.MaximumUrlLength;
string currentFunctionUrl = UrlUtility.AddParameters(_httpContext.Request.Url.AbsolutePath, _queryString, _httpContext.Response.ContentEncoding);
StringCollection parentPermanentUrls = ExtractReturnUrls(currentFunctionUrl);
int count = GetMergeablePermanentUrlCount(permanentUrl, parentPermanentUrls, maxLength);
string parentPermanentUrl = FormatParentPermanentUrl(parentPermanentUrls, count);
if (!string.IsNullOrEmpty(parentPermanentUrl))
{
permanentUrl = UrlUtility.AddParameter(permanentUrl, WxeHandler.Parameters.ReturnUrl, parentPermanentUrl, _httpContext.Response.ContentEncoding);
}
}
return(permanentUrl);
}
public void ExecuteSubFunction_WithPermaUrl_WithParentPermaUrl_DoNotReturnToCaller_GoesToRedirectingToSubFunction ()
{
WxeContext.QueryString.Add ("Key", "NewValue");
WxePermaUrlOptions permaUrlOptions = new WxePermaUrlOptions (true);
IExecutionState executionState = CreateExecutionState (permaUrlOptions, WxeReturnOptions.Null);
ExecutionStateContextMock.Expect (mock => mock.SetExecutionState (Arg<RedirectingToSubFunctionState>.Is.NotNull))
.WhenCalled (
invocation =>
{
var nextState = CheckExecutionState ((RedirectingToSubFunctionState) invocation.Arguments[0]);
Assert.That (nextState.Parameters.SubFunction.ReturnUrl, Is.EqualTo ("DefaultReturn.html"));
string destinationUrl = UrlUtility.AddParameters (
"/session/sub.wxe",
new NameValueCollection
{
{ "Parameter1", "OtherValue" },
{ WxeHandler.Parameters.WxeFunctionToken, SubFunction.FunctionToken },
{ WxeHandler.Parameters.ReturnUrl, "/root.wxe?Key=NewValue" }
},
Encoding.Default);
Assert.That (nextState.Parameters.DestinationUrl, Is.EqualTo (destinationUrl));
});
MockRepository.ReplayAll();
executionState.ExecuteSubFunction (WxeContext);
MockRepository.VerifyAll();
}
public void AddParametersToUrl()
{
string url = "http://localhost/Default.html";
string parameter1 = "Parameter1";
string parameter2 = "Parameter2";
string value1 = "Value1ä#";
string value2 = "Value2";
NameValueCollection queryString = new NameValueCollection();
queryString.Add(parameter1, value1);
queryString.Add(parameter2, value2);
string expected = string.Format(
"{0}?{1}={2}&{3}={4}",
url,
parameter1,
HttpUtility.UrlEncode(value1, _currentEncoding),
parameter2,
HttpUtility.UrlEncode(value2, _currentEncoding));
string actual = UrlUtility.AddParameters(url, queryString, _currentEncoding);
Assert.That(actual, Is.EqualTo(expected));
}
/// <summary>
/// Adds the parameters required for selecting the <paramref name="menuTab"/> to the <paramref name="url"/>.
/// </summary>
/// <param name="url"> The URL. Must not be <see langword="null"/> or empty. </param>
/// <param name="menuTab">
/// The <see cref="MenuTab"/> that should be selected by the <paramref name="url"/>.
/// Must not be <see langword="null"/>.
/// </param>
/// <returns> The <paramref name="url"/> extended with the parameters required by this <see cref="TabbedMenu"/>. </returns>
public string FormatUrl(string url, MenuTab menuTab)
{
ArgumentUtility.CheckNotNullOrEmpty("url", url);
NameValueCollection urlParameters = GetUrlParameters(menuTab);
url = UrlUtility.AddParameters(url, urlParameters);
return(url);
}
/// <summary> Gets the absolute path to the WXE handler used for the current function. </summary>
/// <param name="queryString"> An optional list of URL parameters to be appended to the path. </param>
protected internal string GetPath(NameValueCollection queryString)
{
if (queryString == null)
{
queryString = new NameValueCollection();
}
string path = _httpContext.Response.ApplyAppPathModifier(_httpContext.Request.Url.AbsolutePath);
return(UrlUtility.AddParameters(path, queryString, _httpContext.Response.ContentEncoding));
}
public void AddParametersToUrlNoParameters()
{
string url = "http://localhost/Default.html";
NameValueCollection queryString = new NameValueCollection();
string expected = url;
string actual = UrlUtility.AddParameters(url, queryString, _currentEncoding);
Assert.That(actual, Is.EqualTo(expected));
}
/// <summary> Creates a <see cref="CommandInfo"/> for the <see cref="HrefCommand"/>. </summary>
/// <param name="parameters">
/// The strings inserted into the href attribute using <c>string.Format</c>.
/// </param>
/// <param name="onClick">
/// The string always rendered in the <c>onClick</c> tag of the anchor element.
/// </param>
/// <param name="additionalUrlParameters">
/// The <see cref="NameValueCollection"/> containing additional url parameters.
/// Must not be <see langword="null"/>.
/// </param>
/// <param name="includeNavigationUrlParameters">
/// <see langword="true"/> to include URL parameters provided by <see cref="ISmartNavigablePage"/>.
/// Defaults to <see langword="true"/>.
/// </param>
/// <exception cref="InvalidOperationException">
/// If called while the <see cref="Type"/> is not set to <see cref="CommandType.Href"/>.
/// </exception>
protected virtual CommandInfo GetCommandInfoForHrefCommand(
string[] parameters,
string onClick,
NameValueCollection additionalUrlParameters,
bool includeNavigationUrlParameters)
{
ArgumentUtility.CheckNotNull("parameters", parameters);
ArgumentUtility.CheckNotNull("additionalUrlParameters", additionalUrlParameters);
if (Type != CommandType.Href)
{
throw new InvalidOperationException("Call to GetCommandInfoForHrefCommand not allowed unless Type is set to CommandType.Href.");
}
string href = HrefCommand.FormatHref(parameters);
if (includeNavigationUrlParameters)
{
ISmartNavigablePage page = null;
if (OwnerControl != null)
{
page = OwnerControl.Page as ISmartNavigablePage;
}
if (page != null)
{
additionalUrlParameters = additionalUrlParameters.Clone();
NameValueCollectionUtility.Append(additionalUrlParameters, page.GetNavigationUrlParameters());
}
}
href = UrlUtility.AddParameters(href, additionalUrlParameters);
if (OwnerControl != null)
{
href = OwnerControl.ResolveClientUrl(href);
}
return(CommandInfo.CreateForLink(
StringUtility.EmptyToNull(_toolTip),
StringUtility.EmptyToNull(_accessKey),
href,
StringUtility.EmptyToNull(HrefCommand.Target),
StringUtility.EmptyToNull(onClick)));
}
/// <summary> Gets the absolute path that resumes the function with specified token. </summary>
/// <param name="path"> The path to the <see cref="WxeHandler"/>. Must not be <see langword="null"/> or emtpy. </param>
/// <param name="functionToken">
/// The function token of the function to resume. Must not be <see langword="null"/> or emtpy.
/// </param>
/// <param name="queryString"> An optional list of URL parameters to be appended to the <paramref name="path"/>. </param>
private string GetPath(string path, string functionToken, NameValueCollection queryString)
{
ArgumentUtility.CheckNotNullOrEmpty("path", path);
ArgumentUtility.CheckNotNullOrEmpty("functionToken", functionToken);
if (path.IndexOf("?") != -1)
{
throw new ArgumentException("The path must be provided without a query string. Use the query string parameter instead.", "path");
}
if (queryString == null)
{
queryString = new NameValueCollection();
}
else
{
queryString = NameValueCollectionUtility.Clone(queryString);
}
queryString.Set(WxeHandler.Parameters.WxeFunctionToken, functionToken);
path = UrlUtility.GetAbsoluteUrl(_httpContext, path);
return(UrlUtility.AddParameters(path, queryString, _httpContext.Response.ContentEncoding));
}
/// <summary>
/// Implements <see cref="Remotion.Web.UI.ISmartNavigablePage.AppendNavigationUrlParameters">ISmartNavigablePage.AppendNavigationUrlParameters</see>.
/// </summary>
public string AppendNavigationUrlParameters(string url)
{
NameValueCollection urlParameters = GetNavigationUrlParameters();
return(UrlUtility.AddParameters(url, urlParameters));
}