/// <summary>
/// For the supplied options, return a tab path for the specified tab
/// </summary>
/// <param name="tab">TabInfo object of selected tab</param>
/// <param name="settings">FriendlyUrlSettings</param>
/// <param name="options"></param>
/// <param name="ignoreCustomRedirects">Whether to add in the customised Tab redirects or not</param>
/// <param name="homePageSiteRoot"></param>
/// <param name="isHomeTab"></param>
/// <param name="cultureCode"></param>
/// <param name="isDefaultCultureCode"></param>
/// <param name="hasPath"></param>
/// <param name="dropLangParms"></param>
/// <param name="customHttpAlias"></param>
/// <param name="isCustomPath"></param>
/// <param name="parentTraceId"></param>
/// <remarks>751 : include isDefaultCultureCode flag to determine when using the portal default language
/// 770 : include custom http alias output for when the Url uses a specific alias due to custom Url rules
/// : include new out parameter 'isCustomPath' to return whether the Url was generated from Url-Master custom url
/// </remarks>
/// <returns>The tab path as specified</returns>
internal static string GetTabPath(TabInfo tab,
FriendlyUrlSettings settings,
FriendlyUrlOptions options,
bool ignoreCustomRedirects,
bool homePageSiteRoot,
bool isHomeTab,
string cultureCode,
bool isDefaultCultureCode,
bool hasPath,
out bool dropLangParms,
out string customHttpAlias,
out bool isCustomPath,
Guid parentTraceId)
{
string newTabPath;
dropLangParms = false;
customHttpAlias = null;
isCustomPath = false;
if (homePageSiteRoot && isHomeTab && !hasPath)
// && !isDefaultCultureCode - not working for non-language specifc custom root urls
{
newTabPath = "/"; //site root for home page
}
else
{
//build the tab path and check for space replacement
string baseTabPath = TabIndexController.GetTabPath(tab, options, parentTraceId);
//this is the new tab path
newTabPath = baseTabPath;
//871 : case insensitive compare for culture code, all lookups done on lower case
string cultureCodeKey = "";
if (cultureCode != null)
{
cultureCodeKey = cultureCode.ToLower();
}
bool checkForCustomHttpAlias = false;
//get a custom tab name if redirects are being used
SharedDictionary <string, string> customAliasForTabs = null;
SharedDictionary <int, SharedDictionary <string, string> > urlDict;
//886 : don't fetch custom urls for host tabs (host tabs can't have redirects or custom Urls)
if (tab.PortalID > -1)
{
urlDict = CustomUrlDictController.FetchCustomUrlDictionary(tab.PortalID, false, false, settings, out customAliasForTabs, parentTraceId);
}
else
{
urlDict = new SharedDictionary <int, SharedDictionary <string, string> >();
//create dummy dictionary for this tab
}
if (ignoreCustomRedirects == false)
{
//if not ignoring the custom redirects, look for the Url of the page in this list
//this will be used as the page path if there is one.
using (urlDict.GetReadLock())
{
if (urlDict.ContainsKey(tab.TabID))
{
//we want the custom value
string customTabPath = null;
SharedDictionary <string, string> tabpaths = urlDict[tab.TabID];
using (tabpaths.GetReadLock())
{
if (tabpaths.ContainsKey(cultureCodeKey))
{
customTabPath = tabpaths[cultureCodeKey];
dropLangParms = true;
//the url is based on a custom value which has embedded language parms, therefore don't need them in the url
}
else
{
if (isDefaultCultureCode && tabpaths.ContainsKey(""))
{
customTabPath = tabpaths[""];
//dropLangParms = true;//drop the language parms if they exist, because this is the default language
}
}
}
if (customTabPath != null)
{
//770 : pull out custom http alias if in string
int aliasSeparator = customTabPath.IndexOf("::", StringComparison.Ordinal);
if (aliasSeparator > 0)
{
customHttpAlias = customTabPath.Substring(0, aliasSeparator);
newTabPath = customTabPath.Substring(aliasSeparator + 2);
}
else
{
newTabPath = customTabPath;
}
}
if (newTabPath == "" && hasPath)
{
//can't pass back a custom path which is blank if there are path segments to the requested final Url
newTabPath = baseTabPath; //revert back to the standard DNN page path
}
else
{
isCustomPath = true; //we are providing a custom Url
}
}
else
{
checkForCustomHttpAlias = true;
}
}
}
else
{
checkForCustomHttpAlias = true;
//always want to check for custom alias, even when we don't want to see any custom redirects
}
//770 : check for custom alias in these tabs
if (checkForCustomHttpAlias && customAliasForTabs != null)
{
string key = tab.TabID.ToString() + ":" + cultureCodeKey;
using (customAliasForTabs.GetReadLock())
{
if (customAliasForTabs.ContainsKey(key))
{
//this tab uses a custom alias
customHttpAlias = customAliasForTabs[key];
isCustomPath = true; //using custom alias
}
}
}
if (!dropLangParms)
{
string tabCultureCode = tab.CultureCode;
if (!string.IsNullOrEmpty(tabCultureCode))
{
dropLangParms = true;
//if the tab has a specified culture code, then drop the language parameters from the friendly Url
}
}
//make lower case if necessary
newTabPath = AdvancedFriendlyUrlProvider.ForceLowerCaseIfAllowed(tab, newTabPath, settings);
}
return(newTabPath);
}
internal static bool CheckUserProfileReplacement(string newPath,
TabInfo tab,
PortalSettings portalSettings,
FriendlyUrlSettings settings,
FriendlyUrlOptions options,
out string changedPath,
out bool changeToSiteRoot,
out bool allowOtherParameters,
ref List <string> meessages,
Guid parentTraceId)
{
if (meessages == null)
{
meessages = new List <string>();
}
bool urlWasChanged = false;
//initialise defaults to always return valid items
changedPath = newPath;
changeToSiteRoot = false;
allowOtherParameters = true;
//determine if this url should be converted to a userprofile url by checking the saved rules matching the tab/portalid
if (portalSettings != null && tab.PortalID == portalSettings.PortalId &&
(tab.TabID == portalSettings.UserTabId || portalSettings.UserTabId == -1 ||
tab.ParentId == portalSettings.UserTabId)) //-1 == all tabs in portal
{
int userId;
string rawUserId, remainingPath;
//split the userid and other profile parameters from the friendly url path,
//and return the userid and remaining parts as separate items
SplitUserIdFromFriendlyUrlPath(newPath,
"UserId",
"",
out rawUserId,
out remainingPath);
if (rawUserId != null)
{
meessages.Add("User Profile Url : RawUserId = " + rawUserId + " remainingPath = " + remainingPath);
}
else
{
meessages.Add("User Profile Url : RawUserId = " + "null" + " remainingPath = " + remainingPath);
}
//the rawuserid is just the string representation of the userid from the path.
//It should be considered 'untrusted' until cleaned up,
//converted to an int and checked against the database
if (!String.IsNullOrEmpty(rawUserId) && Int32.TryParse(rawUserId, out userId))
{
bool doReplacement = false;
string urlName = String.Empty;
//Get the User
var user = UserController.GetUserById(portalSettings.PortalId, userId);
if (user != null && !String.IsNullOrEmpty(user.VanityUrl))
{
doReplacement = true;
urlName = (!String.IsNullOrEmpty(settings.VanityUrlPrefix)) ? String.Format("{0}/{1}", settings.VanityUrlPrefix, user.VanityUrl) : user.VanityUrl;
urlWasChanged = true;
}
if (doReplacement)
{
//check to see whether this is a match on the parentid or not
if (portalSettings.UserTabId == tab.ParentId && portalSettings.UserTabId > -1)
{
//replacing for the parent tab id
string childTabPath = TabIndexController.GetTabPath(tab, options, parentTraceId);
if (string.IsNullOrEmpty(childTabPath) == false)
{
//remove the parent tab path from the child tab path
var tc = new TabController();
TabInfo profilePage = tc.GetTab(tab.ParentId, tab.PortalID, false);
string profilePagePath = TabIndexController.GetTabPath(profilePage, options, parentTraceId);
if (childTabPath.Contains(profilePagePath))
{
//only replace when the child tab path contains the parent path - if it's a custom url that
//doesn't incorporate the parent path, then leave it alone
childTabPath = childTabPath.Replace(profilePagePath, "");
childTabPath = childTabPath.Replace("//", "/");
remainingPath += FriendlyUrlController.EnsureLeadingChar("/", childTabPath);
}
}
}
changedPath = "/" + urlName;
//append any extra remaining path value to the end
if (!string.IsNullOrEmpty(remainingPath))
{
if (remainingPath.StartsWith("/") == false)
{
changedPath += "/" + remainingPath;
}
else
{
changedPath += remainingPath;
}
}
urlWasChanged = true;
changeToSiteRoot = true; //we will be doing domain.com/urlname
allowOtherParameters = false;
//can't have any others (wouldn't have matched in the regex if there were)
}
else
{
meessages.Add("User Profile : doReplacement = false");
}
}
}
return(urlWasChanged);
}
internal static bool CheckForParameterRedirect(Uri requestUri,
ref UrlAction result,
NameValueCollection queryStringCol,
FriendlyUrlSettings settings)
{
//check for parameter replaced works by inspecting the parameters on a rewritten request, comparing
//them agains the list of regex expressions on the friendlyurls.config file, and redirecting to the same page
//but with new parameters, if there was a match
bool redirect = false;
//get the redirect actions for this portal
var messages = new List <string>();
Dictionary <int, List <ParameterRedirectAction> > redirectActions = CacheController.GetParameterRedirects(settings, result.PortalId, ref messages);
if (redirectActions != null && redirectActions.Count > 0)
{
try
{
#region trycatch block
string rewrittenUrl = result.RewritePath ?? result.RawUrl;
List <ParameterRedirectAction> parmRedirects = null;
//find the matching redirects for the tabid
int tabId = result.TabId;
if (tabId > -1)
{
if (redirectActions.ContainsKey(tabId))
{
//find the right set of replaced actions for this tab
parmRedirects = redirectActions[tabId];
}
}
//check for 'all tabs' redirections
if (redirectActions.ContainsKey(-1)) //-1 means 'all tabs' - rewriting across all tabs
{
//initialise to empty collection if there are no specific tab redirects
if (parmRedirects == null)
{
parmRedirects = new List <ParameterRedirectAction>();
}
//add in the all redirects
List <ParameterRedirectAction> allRedirects = redirectActions[-1];
parmRedirects.AddRange(allRedirects); //add the 'all' range to the tab range
tabId = result.TabId;
}
if (redirectActions.ContainsKey(-2) && result.OriginalPath.ToLowerInvariant().Contains("default.aspx"))
{
//for the default.aspx page
if (parmRedirects == null)
{
parmRedirects = new List <ParameterRedirectAction>();
}
List <ParameterRedirectAction> defaultRedirects = redirectActions[-2];
parmRedirects.AddRange(defaultRedirects); //add the default.aspx redirects to the list
tabId = result.TabId;
}
//726 : allow for site-root redirects, ie redirects where no page match
if (redirectActions.ContainsKey(-3))
{
//request is for site root
if (parmRedirects == null)
{
parmRedirects = new List <ParameterRedirectAction>();
}
List <ParameterRedirectAction> siteRootRedirects = redirectActions[-3];
parmRedirects.AddRange(siteRootRedirects); //add the site root redirects to the collection
}
//OK what we have now is a list of redirects for the currently requested tab (either because it was specified by tab id,
// or because there is a replaced for 'all tabs'
if (parmRedirects != null && parmRedirects.Count > 0 && rewrittenUrl != null)
{
foreach (ParameterRedirectAction parmRedirect in parmRedirects)
{
//regex test each replaced to see if there is a match between the parameter string
//and the parmRedirect
string compareWith = rewrittenUrl;
var redirectRegex = RegexUtils.GetCachedRegex(parmRedirect.LookFor,
RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
Match regexMatch = redirectRegex.Match(compareWith);
bool success = regexMatch.Success;
bool siteRootTried = false;
//if no match, but there is a site root redirect to try
if (!success && parmRedirect.TabId == -3)
{
siteRootTried = true;
compareWith = result.OriginalPathNoAlias;
regexMatch = redirectRegex.Match(compareWith);
success = regexMatch.Success;
}
if (!success)
{
result.DebugMessages.Add(parmRedirect.Name + " redirect not matched (" + rewrittenUrl +
")");
if (siteRootTried)
{
result.DebugMessages.Add(parmRedirect.Name + " redirect not matched [site root] (" +
result.OriginalPathNoAlias + ")");
}
}
else
{
//success! there was a match in the parameters
string parms = redirectRegex.Replace(compareWith, parmRedirect.RedirectTo);
if (siteRootTried)
{
result.DebugMessages.Add(parmRedirect.Name + " redirect matched [site root] with (" +
result.OriginalPathNoAlias + "), replaced with " + parms);
}
else
{
result.DebugMessages.Add(parmRedirect.Name + " redirect matched with (" +
compareWith + "), replaced with " + parms);
}
string finalUrl = "";
//now we need to generate the friendly Url
//first check to see if the parameter replacement string has a destination tabid specified
if (parms.ToLowerInvariant().Contains("tabid/"))
{
//if so, using a feature whereby the dest tabid can be changed within the parameters, which will
//redirect the page as well as redirecting the parameter values
string[] parmParts = parms.Split('/');
bool tabIdNext = false;
foreach (string parmPart in parmParts)
{
if (tabIdNext)
{
//changes the tabid of page, effects a page redirect along with a parameter redirect
Int32.TryParse(parmPart, out tabId);
parms = parms.Replace("tabid/" + tabId.ToString(), "");
//remove the tabid/xx from the path
break; //that's it, we're finished
}
if (parmPart.Equals("tabid", StringComparison.InvariantCultureIgnoreCase))
{
tabIdNext = true;
}
}
}
else if (tabId == -1)
{
//find the home tabid for this portal
//735 : switch to custom method for getting portal
PortalInfo portal = CacheController.GetPortal(result.PortalId, true);
tabId = portal.HomeTabId;
}
if (parmRedirect.ChangeToSiteRoot)
{
//when change to siteroot requested, new path goes directly off the portal alias
//so set the finalUrl as the poratl alias
finalUrl = result.Scheme + result.HttpAlias + "/";
}
else
{
//if the tabid has been supplied, do a friendly url provider lookup to get the correct format for the tab url
if (tabId > -1)
{
TabInfo tab = TabController.Instance.GetTab(tabId, result.PortalId, false);
if (tab != null)
{
string path = Globals.glbDefaultPage + TabIndexController.CreateRewritePath(tab.TabID, "");
string friendlyUrlNoParms = AdvancedFriendlyUrlProvider.ImprovedFriendlyUrl(tab,
path,
Globals.glbDefaultPage,
result.HttpAlias,
false,
settings,
Guid.Empty);
if (friendlyUrlNoParms.EndsWith("/") == false)
{
friendlyUrlNoParms += "/";
}
finalUrl = friendlyUrlNoParms;
}
if (tab == null)
{
result.DebugMessages.Add(parmRedirect.Name +
" tabId in redirect rule (tabId:" +
tabId.ToString() + ", portalId:" +
result.PortalId.ToString() +
" ), tab was not found");
}
else
{
result.DebugMessages.Add(parmRedirect.Name +
" tabId in redirect rule (tabId:" +
tabId.ToString() + ", portalId:" +
result.PortalId.ToString() + " ), tab found : " +
tab.TabName);
}
}
}
if (parms.StartsWith("//"))
{
parms = parms.Substring(2);
}
if (parms.StartsWith("/"))
{
parms = parms.Substring(1);
}
if (settings.PageExtensionUsageType != PageExtensionUsageType.Never)
{
if (parms.EndsWith("/"))
{
parms = parms.TrimEnd('/');
}
if (parms.Length > 0)
{
//we are adding more parms onto the end, so remove the page extension
//from the parameter list
//946 : exception when settings.PageExtension value is empty
parms += settings.PageExtension;
//816: if page extension is /, then don't do this
if (settings.PageExtension != "/" &&
string.IsNullOrEmpty(settings.PageExtension) == false)
{
finalUrl = finalUrl.Replace(settings.PageExtension, "");
}
}
else
{
//we are removing all the parms altogether, so
//the url needs to end in the page extension only
//816: if page extension is /, then don't do this
if (settings.PageExtension != "/" &&
string.IsNullOrEmpty(settings.PageExtension) == false)
{
finalUrl = finalUrl.Replace(settings.PageExtension + "/",
settings.PageExtension);
}
}
}
//put the replaced parms back on the end
finalUrl += parms;
//set the final url
result.FinalUrl = finalUrl;
result.Reason = RedirectReason.Custom_Redirect;
switch (parmRedirect.Action)
{
case "301":
result.Action = ActionType.Redirect301;
break;
case "302":
result.Action = ActionType.Redirect302;
break;
case "404":
result.Action = ActionType.Output404;
break;
}
redirect = true;
break;
}
}
}
#endregion
}
catch (Exception ex)
{
Services.Exceptions.Exceptions.LogException(ex);
messages.Add("Exception: " + ex.Message + "\n" + ex.StackTrace);
}
finally
{
if (messages.Count > 0)
{
result.DebugMessages.AddRange(messages);
}
}
}
return(redirect);
}
