/// <summary>
        /// Generate WebAPI Links compatible with DNN Services Framework
        /// </summary>
        /// <param name="urlHelper">The UrlHelper</param>
        /// <param name="moduleFolderName">ModuleFolderName for the route</param>
        /// <param name="routeName">RouteName for the route</param>
        /// <param name="routeValues">Values to be passed to the route</param>
        /// <param name="portalAliasInfo">The PortalAlias to use in the Url </param>
        /// <returns>a url</returns>
        public static string DnnLink(this UrlHelper urlHelper, string moduleFolderName, string routeName, object routeValues, PortalAliasInfo portalAliasInfo)
        {
            var parm = new PortalAliasRouteManager();
            var fullName = parm.GetRouteName(moduleFolderName, routeName, PortalController.Instance.GetCurrentPortalSettings().PortalAlias);
            HttpRouteValueDictionary allRouteValues = parm.GetAllRouteValues(portalAliasInfo, routeValues);

            return urlHelper.Link(fullName, allRouteValues);
        }

 public PortalAliasInfo(PortalAliasInfo alias)
 {
     HTTPAlias = alias.HTTPAlias;
     PortalAliasID = alias.PortalAliasID;
     PortalID = alias.PortalID;
     IsPrimary = alias.IsPrimary;
     Redirect = alias.Redirect;
     BrowserType = alias.BrowserType;
     CultureCode = alias.CultureCode;
     Skin = alias.Skin;
 }

        protected static void AutoAddAlias(HttpContext context)
        {
            var portalId = Host.Host.HostPortalID;
            //the domain name was not found so try using the host portal's first alias
            if (portalId > Null.NullInteger)
            {
                var portalAliasInfo = new PortalAliasInfo { PortalID = portalId, HTTPAlias = Globals.GetDomainName(context.Request, true) };
                PortalAliasController.Instance.AddPortalAlias(portalAliasInfo);

                context.Response.Redirect(context.Request.Url.ToString(), true);
            }
        }

        public HttpRouteValueDictionary GetAllRouteValues(PortalAliasInfo portalAliasInfo, object routeValues)
        {
            var allRouteValues = new HttpRouteValueDictionary(routeValues);

            var segments = portalAliasInfo.HTTPAlias.Split('/');
            
            if(segments.Length > 1)
            {
                  for(int i = 1; i < segments.Length; i++)
                  {
                      var key = "prefix" + (i - 1).ToString(CultureInfo.InvariantCulture);
                      var value = segments[i];
                      allRouteValues.Add(key, value);
                  }
            }

            return allRouteValues;
        }

 public ArrayList GetPortalAliasArrayByPortalID(int PortalID)
 {
     IDataReader dr = DotNetNuke.Data.DataProvider.Instance().GetPortalAliasByPortalID(PortalID);
     try
     {
         ArrayList arr = new ArrayList();
         while (dr.Read())
         {
             PortalAliasInfo objPortalAliasInfo = new PortalAliasInfo();
             objPortalAliasInfo.PortalAliasID = Convert.ToInt32(dr["PortalAliasID"]);
             objPortalAliasInfo.PortalID = Convert.ToInt32(dr["PortalID"]);
             objPortalAliasInfo.HTTPAlias = Convert.ToString(dr["HTTPAlias"]).ToLower();
             arr.Add(objPortalAliasInfo);
         }
         return arr;
     }
     finally
     {
         if (dr != null)
         {
             dr.Close();
         }
     }
 }

 public PortalAliasCollection GetPortalAliasByPortalID(int PortalID)
 {
     IDataReader dr = DotNetNuke.Data.DataProvider.Instance().GetPortalAliasByPortalID(PortalID);
     try
     {
         PortalAliasCollection objPortalAliasCollection = new PortalAliasCollection();
         while (dr.Read())
         {
             PortalAliasInfo objPortalAliasInfo = new PortalAliasInfo();
             objPortalAliasInfo.PortalAliasID = Convert.ToInt32(dr["PortalAliasID"]);
             objPortalAliasInfo.PortalID = Convert.ToInt32(dr["PortalID"]);
             objPortalAliasInfo.HTTPAlias = Convert.ToString(dr["HTTPAlias"]);
             objPortalAliasCollection.Add(Convert.ToString(dr["HTTPAlias"]).ToLower(), objPortalAliasInfo);
         }
         return objPortalAliasCollection;
     }
     finally
     {
         if (dr != null)
         {
             dr.Close();
         }
     }
 }

        public void AdvancedUrlRewriter_PrimaryPortalAlias(Dictionary<string, string> testFields)
        {
            string defaultAlias = testFields["DefaultAlias"];

            var settings = UrlTestFactoryClass.GetSettings("UrlRewrite", testFields["TestName"]);

            settings.PortalId = PortalId;

            string language = testFields["Language"].Trim();
            string skin = testFields["Skin"].Trim();
            if (!String.IsNullOrEmpty(language))
            {
                _customLocale = new Locale { Code = language, Fallback = "en-US" };
                _customLocale.Text = CultureInfo.CreateSpecificCulture(_customLocale.Code).NativeName;
                Localization.SaveLanguage(_customLocale);
                Localization.AddLanguageToPortals(_customLocale.LanguageId);

            }

            if (testFields.ContainsKey("Final Url"))
            {
                testFields["Final Url"] = testFields["Final Url"].Replace("{useAlias}", defaultAlias);
            }

            if (!(String.IsNullOrEmpty(language) && String.IsNullOrEmpty(skin)))
            {
                //add new primary alias
                _primaryAlias = new PortalAliasInfo
                                    {
                                        PortalID = PortalId,
                                        HTTPAlias = defaultAlias,
                                        CultureCode = language,
                                        Skin = skin,
                                        IsPrimary = true
                                    };
                _primaryAlias.PortalAliasID = TestablePortalAliasController.Instance.AddPortalAlias(_primaryAlias);
                ExecuteTest(settings, testFields, true);
            }
            else
            {
                SetDefaultAlias(defaultAlias);
                ExecuteTest(settings, testFields, false);
            }

        }

 protected abstract void GetPortalAliasProperties(int index, PortalAliasInfo portalAlias);

        private static void AddLanguageHttpAlias(int portalId, Locale locale)
        {
            if (Config.GetFriendlyUrlProvider() == "advanced")
            {
                // create new HTTPAlias for language
                var portalInfo = PortalController.Instance.GetPortal(portalId);
                PortalAliasInfo currentAlias = null;
                string httpAlias = null;

                var portalAliasses = PortalAliasController.Instance.GetPortalAliasesByPortalId(portalId);
                var portalAliasInfos = portalAliasses as IList<PortalAliasInfo> ?? portalAliasses.ToList();
                if (portalAliasses != null && portalAliasInfos.Any())
                {
                    currentAlias = portalAliasInfos.First();
                    httpAlias = currentAlias.HTTPAlias;
                }

                if (currentAlias != null && !string.IsNullOrEmpty(httpAlias) && portalInfo != null)
                {

                    if (!string.IsNullOrEmpty(currentAlias.CultureCode))
                    {
                        // the portal alias is culture specific
                        if (currentAlias.CultureCode == portalInfo.CultureCode)
                        {
                            // remove the culture from the alias
                            httpAlias = httpAlias.Substring(0, httpAlias.LastIndexOf("/", StringComparison.Ordinal));
                        }
                    }

                    var alias = GetValidLanguageURL(portalId, httpAlias, locale.Code.ToLowerInvariant());
                    if (!String.IsNullOrEmpty(alias))
                    {
                        var newAlias = new PortalAliasInfo(currentAlias)
                            {
                                IsPrimary = true,
                                CultureCode = locale.Code,
                                HTTPAlias = GetValidLanguageURL(portalId, httpAlias, locale.Code.ToLowerInvariant())
                            };

                        PortalAliasController.Instance.AddPortalAlias(newAlias);
                    }
                }
            }
        }

 protected string AddPortalAlias(string portalAlias, int portalID)
 {
     if (!String.IsNullOrEmpty(portalAlias))
     {
         if (portalAlias.IndexOf("://", StringComparison.Ordinal) != -1)
         {
             portalAlias = portalAlias.Remove(0, portalAlias.IndexOf("://", StringComparison.Ordinal) + 3);
         }
         var alias = PortalAliasController.Instance.GetPortalAlias(portalAlias, portalID);
         if (alias == null)
         {
             alias = new PortalAliasInfo { PortalID = portalID, HTTPAlias = portalAlias };
             PortalAliasController.Instance.AddPortalAlias(alias);
         }
     }
     return portalAlias;
 }

        protected void AddAlias(object sender, EventArgs e)
        {
            //Add a new empty rule and set the editrow to the new row
            var portalAlias = new PortalAliasInfo { PortalID = CurrentPortalId };
            Aliases.Add(portalAlias);
            Grid.EditItemIndex = Aliases.Count - 1;

            //Set the AddMode to true
            AddMode = true;

            //Rebind the collection
            BindAliases();
        }

 private static string MakeUrlWithAlias(Uri requestUri, PortalAliasInfo alias)
 {
     return MakeUrlWithAlias(requestUri, alias.HTTPAlias);
 }

        public void AdvancedUrlProvider_PrimaryPortalAlias(Dictionary<string, string> testFields)
        {
            string defaultAlias = testFields["DefaultAlias"];
            string redirectMode = testFields["RedirectMode"];

            var settings = UrlTestFactoryClass.GetSettings("FriendlyUrl", "PrimaryPortalAlias");

            string language = testFields["Language"].Trim();
            if (!String.IsNullOrEmpty(language))
            {
                _customLocale = new Locale { Code = language, Fallback = "en-US" };
                _customLocale.Text = CultureInfo.CreateSpecificCulture(_customLocale.Code).NativeName;
                Localization.SaveLanguage(_customLocale);
                Localization.AddLanguageToPortals(_customLocale.LanguageId);

                //add new primary alias
                _primaryAlias = new PortalAliasInfo
                {
                    PortalID = PortalId,
                    HTTPAlias = defaultAlias,
                    CultureCode = language,
                    IsPrimary = true
                };
                _primaryAlias.PortalAliasID = PortalAliasController.Instance.AddPortalAlias(_primaryAlias);
            }
            else
            {
                SetDefaultAlias(defaultAlias);
            }

            PortalController.UpdatePortalSetting(PortalId, "PortalAliasMapping", redirectMode);

            ExecuteTest("Improved", settings, testFields);
        }

 /// <summary>
 /// Gets the host portal settings.
 /// </summary>
 /// <returns>Host portal settings</returns>
 public static PortalSettings GetHostPortalSettings()
 {
     int TabId = -1;
     int PortalId = -1;
     PortalAliasInfo objPortalAliasInfo = null;
     //if the portal alias exists
     if (Host.HostPortalID > Null.NullInteger)
     {
         PortalId = Host.HostPortalID;
         // use the host portal
         objPortalAliasInfo = new PortalAliasInfo();
         objPortalAliasInfo.PortalID = PortalId;
     }
     // load the PortalSettings into current context
     return new PortalSettings(TabId, objPortalAliasInfo);
 }

 protected string AddPortalAlias(string portalAlias, int portalID)
 {
     if (!String.IsNullOrEmpty(portalAlias))
     {
         if (portalAlias.IndexOf("://") != -1)
         {
             portalAlias = portalAlias.Remove(0, portalAlias.IndexOf("://") + 3);
         }
         var objPortalAliasController = new PortalAliasController();
         var objPortalAlias = objPortalAliasController.GetPortalAlias(portalAlias, portalID);
         if (objPortalAlias == null)
         {
             objPortalAlias = new PortalAliasInfo { PortalID = portalID, HTTPAlias = portalAlias };
             objPortalAliasController.AddPortalAlias(objPortalAlias);
         }
     }
     return portalAlias;
 }

 public override string TransformFriendlyUrlToQueryString(string[] urlParms, int tabId, int portalId, FriendlyUrlOptions options, string cultureCode, PortalAliasInfo portalAlias, ref List<string> messages, out int status, out string location)
 {
     throw new NotImplementedException();
 }

        public void AdvancedUrlRewriter_PrimaryPortalAlias(Dictionary<string, string> testFields)
        {
            string defaultAlias = testFields["DefaultAlias"];

            var settings = UrlTestFactoryClass.GetSettings("UrlRewrite", testFields["TestName"]);

            settings.PortalId = PortalId;

            string language = testFields["Language"].Trim();
            string skin = testFields["Skin"].Trim();
            if (!String.IsNullOrEmpty(language))
            {
                _customLocale = new Locale { Code = language, Fallback = "en-US" };
                _customLocale.Text = CultureInfo.GetCultureInfo(_customLocale.Code).NativeName;
                Localization.SaveLanguage(_customLocale);
                Localization.AddLanguageToPortals(_customLocale.LanguageId);

            }

            if (testFields.ContainsKey("Final Url"))
            {
                testFields["Final Url"] = testFields["Final Url"].Replace("{useAlias}", defaultAlias);
            }

            PortalController.UpdatePortalSetting(PortalId, "PortalAliasMapping", "REDIRECT", "en-us");
            var alias = PortalAliasController.Instance.GetPortalAlias(defaultAlias, PortalId);
            if (alias == null)
            {
                alias = new PortalAliasInfo
                {
                    HTTPAlias = defaultAlias,
                    PortalID = PortalId,
                    IsPrimary = true
                };
                if (!(String.IsNullOrEmpty(language) && String.IsNullOrEmpty(skin)))
                {
                    alias.CultureCode = language;
                    alias.Skin = skin;
                }
               PortalAliasController.Instance.AddPortalAlias(alias);
            }
            SetDefaultAlias(defaultAlias);
            ExecuteTest(settings, testFields, false);


            alias = PortalAliasController.Instance.GetPortalAlias(defaultAlias, PortalId);
            if (alias != null)
            {
                PortalAliasController.Instance.DeletePortalAlias(alias);
            }
        }

        /// <summary>
        /// Creates a new portal alias
        /// </summary>
        /// <param name="PortalId">Id of the portal</param>
        /// <param name="PortalAlias">Portal Alias to be created</param>
        /// <history>
        ///     [cnurse]    01/11/2005  created
        /// </history>
        public void AddPortalAlias( int PortalId, string PortalAlias )
        {
            PortalAliasController objPortalAliasController = new PortalAliasController();

            //Check if the Alias exists
            PortalAliasInfo objPortalAliasInfo = objPortalAliasController.GetPortalAlias( PortalAlias, PortalId );

            //If alias does not exist add new
            if( objPortalAliasInfo == null )
            {
                objPortalAliasInfo = new PortalAliasInfo();
                objPortalAliasInfo.PortalID = PortalId;
                objPortalAliasInfo.HTTPAlias = PortalAlias;
                objPortalAliasController.AddPortalAlias( objPortalAliasInfo );
            }
        }

        private static OrderedDictionary BuildPortalAliasesRegexDictionary()
        {
            IDictionary<string, PortalAliasInfo> aliases = TestablePortalAliasController.Instance.GetPortalAliases();
            //create a new OrderedDictionary.  We use this because we
            //want to key by the correct regex pattern and return the
            //portalAlias that matches, and we want to preserve the
            //order of the items, such that the item with the most path separators (/)
            //is at the front of the list.  
            var regexList = new OrderedDictionary(aliases.Count);
            //this regex pattern, when formatted with the httpAlias, will match a request 
            //for this portalAlias
            const string aliasRegexPattern = @"(?:^(?<http>http[s]{0,1}://){0,1})(?:(?<alias>_ALIAS_)(?<path>$|\?[\w]*|/[\w]*))";
            var pathLengths = new List<int>();
            foreach (string aliasKey in aliases.Keys)
            {
                PortalAliasInfo alias = aliases[aliasKey];
                //regex escape the portal alias for inclusion into a regex pattern
                string plainAlias = alias.HTTPAlias;
                string escapedAlias = Regex.Escape(plainAlias);
                var aliasesToAdd = new List<string> { escapedAlias };
                //check for existence of www. version of domain, if it doesn't have a www.
                if (plainAlias.ToLower().StartsWith("www."))
                {
                    if (plainAlias.Length > 4)
                    {
                        string noWWWVersion = plainAlias.Substring(4);
                        if (!aliases.ContainsKey(noWWWVersion))
                        {
                            //there is no no-www version of the alias
                            aliasesToAdd.Add(Regex.Escape(noWWWVersion));
                        }
                    }
                }
                else
                {
                    string wwwVersion = "www." + plainAlias;
                    if (!aliases.ContainsKey(wwwVersion))
                    {
                        aliasesToAdd.Add(Regex.Escape(wwwVersion));
                    }
                }
                int count = 0;
                foreach (string aliasToAdd in aliasesToAdd)
                {
                    //set flag on object to know whether to redirect or not
                    count++;
                    var aliasObject = new PortalAliasInfo(alias) { Redirect = count != 1 };

                    //format up the regex pattern by replacing the alias portion with the portal alias name
                    string regexPattern = aliasRegexPattern.Replace("_ALIAS_", aliasToAdd);
                    //work out how many path separators there are in the portalAlias (ie myalias/mychild = 1 path)
                    int pathLength = plainAlias.Split('/').GetUpperBound(0);
                    //now work out where in the list we should put this portalAlias regex pattern
                    //the list is to be sorted so that those aliases with the most paths 
                    //are at the front of the list : ie, they are tested first
                    int insertPoint = pathLengths.Count - 1;
                    //walk through the existing list of path lengths,
                    //and ascertain where in the list this one falls
                    //if they are all the same path length, then place them in portal alias order
                    for (int i = 0; i < pathLengths.Count; i++)
                    {
                        insertPoint = i;
                        if (pathLength > pathLengths[i])
                        {
                            //larger than this position, insert at this value
                            break;
                        }
                        insertPoint++; //next one along (if at end, means add)
                    }
                    if (pathLengths.Count > 0 && insertPoint <= pathLengths.Count - 1)
                    {
                        //put the new regex pattern into the correct position
                        regexList.Insert(insertPoint, regexPattern, aliasObject);
                        pathLengths.Insert(insertPoint, pathLength);
                    }
                    else
                    {
                        //put the new regex pattern on the end of the list
                        regexList.Add(regexPattern, aliasObject);
                        pathLengths.Add(pathLength);
                    }
                }
            }
            return regexList;
        }

        public override void TestFixtureSetUp()
        {
            base.TestFixtureSetUp();

            var tab = TabController.Instance.GetTabByName(_aboutUsPageName, PortalId);
            if (tab == null)
            {
                CreateTab(_aboutUsPageName);
                tab = TabController.Instance.GetTabByName(_aboutUsPageName, PortalId);
            }
            _tabId = tab.TabID;

            //Add Portal Aliases
            var aliasController = PortalAliasController.Instance;
            TestUtil.ReadStream(String.Format("{0}", "Aliases"), (line, header) =>
                        {
                            string[] fields = line.Split(',');
                            var alias = aliasController.GetPortalAlias(fields[0], PortalId);
                            if (alias == null)
                            {
                                alias = new PortalAliasInfo
                                                {
                                                    HTTPAlias = fields[0],
                                                    PortalID = PortalId
                                                };
                                PortalAliasController.Instance.AddPortalAlias(alias);
                            }
                        });
            TestUtil.ReadStream(String.Format("{0}", "Users"), (line, header) =>
                        {
                            string[] fields = line.Split(',');

                            TestUtil.AddUser(PortalId, fields[0].Trim(), fields[1].Trim(), fields[2].Trim());
                        });
        }