siteurls.cs

本系统是在asp版《在线文件管理器》的基础上设计制作

		public virtual string UserChangePasswordAnswer 
		{
			get { return urlData.FormatUrl("user_ChangePasswordAnswer"); }
		}

		public virtual string UserForgotPassword 
		{
			get { return urlData.FormatUrl("user_ForgotPassword"); }
		}
        
		public virtual string UserRegister 
		{
			get 
			{ 
				string currentPath = CSContext.Current.Context.Request.Url.PathAndQuery;
				string returnUrl = null;

				if (ExtractQueryParams(currentPath)["ReturnUrl"] != null)
					returnUrl = ExtractQueryParams(currentPath)["ReturnUrl"];

				if ((returnUrl == null) || (returnUrl == string.Empty))
					return urlData.FormatUrl("user_Register", currentPath);
				else
					return urlData.FormatUrl("user_Register", returnUrl);

			}
		}

		public virtual string UserList 
		{
			get { return urlData.FormatUrl("user_List"); }
		}

		public virtual string UserRoles (string roleGuid) 
		{
			return urlData.FormatUrl("user_Roles", roleGuid );
		}
		#endregion

		#region Private Messages
		// Private Messages
		//
		public virtual string PrivateMessage (int userID) 
		{
			return urlData.FormatUrl("privateMessage", userID.ToString());
		}

		public virtual string UserPrivateMessages 
		{
			get { return urlData.FormatUrl("privateMessages"); }
		}

		#endregion

		#region Email
		// Email
		//
		public virtual string EmailToUser (int userID) 
		{
			return urlData.FormatUrl("email_ToUser", userID.ToString());
		}
		#endregion

        #region Emoticon
        // Resolves the absolute path to emoticon images
        //
        public virtual string Emoticon 
        {
            get { return urlData.FormatUrl("emoticons"); }
        }
        #endregion

		#region RSS
		// RSS
		//
		public virtual string RssForum (int forumID, ThreadViewMode mode) 
		{
			return urlData.FormatUrl("rss", forumID.ToString(), ((int) mode).ToString());
		}

        public virtual string AggView(int postid)
        {
            return urlData.FormatUrl("aggview",postid);
        }
		#endregion

		#region Search
		public virtual string Search 
		{
			get { return urlData.FormatUrl("search"); }
		}

		public virtual string SearchAdvanced 
		{
			get { return urlData.FormatUrl("search_Advanced"); }
		}

		public virtual string SearchForText(string textToSearchFor) 
		{
			return SearchForText(textToSearchFor, "", "");
		}

		public virtual string SearchForText(string textToSearchFor, string forumsToSearch, string usersToSearch) 
		{
			if (enableWaitPage)
				return urlData.FormatUrl("wait", (urlData.FormatUrl("search_ForText", textToSearchFor, forumsToSearch, usersToSearch)));
			else
				return urlData.FormatUrl("search_ForText", textToSearchFor, forumsToSearch, usersToSearch);
		}

		public virtual string GallerySearchForText(string textToSearchFor, string forumsToSearch)
		{
			if (enableWaitPage)
				return urlData.FormatUrl("wait", (urlData.FormatUrl("gallery_Search", textToSearchFor, forumsToSearch)));
			else
				return urlData.FormatUrl("gallery_Search", textToSearchFor, forumsToSearch);
		}


		public virtual string SearchByUser (int userID) 
		{
			string encodedUserID = CommunityServer.Search.ForumsToSearchEncode(userID.ToString());

			return SearchForText("", "", encodedUserID);
		}

		public virtual string SearchForUser (string username) 
		{
			return urlData.FormatUrl("search_ForUser", username);
		}

		public virtual string SearchForUserAdmin (string username) 
		{
			return urlData.FormatUrl("search_ForUserAdmin", username);
		}
		#endregion

		#region FAQ
		public virtual string FAQ 
		{
			get { return urlData.FormatUrl("faq", CSContext.Current.User.Profile.Language); }
		}
		#endregion

        #region TOU
		public virtual string TermsOfUse 
		{
			get 
			{ 
				string termsOfUse = "";
				try 
				{
					termsOfUse = urlData.FormatUrl("termsOfUse");
				}
				catch 
				{
					termsOfUse = "";
				}

				return termsOfUse;
			}
		}

        #endregion

		#region Login, Logout, Messages
		public virtual string LoginReturnHome 
		{
			get 
			{
				return urlData.FormatUrl("login", Globals.ApplicationPath);
			}
		}

		public virtual string Login 
		{
			get 
			{ 
				string currentPath = CSContext.Current.Context.Request.Url.PathAndQuery;
				string returnUrl = null;

				//if (ExtractQueryParams(currentPath)["ReturnUrl"] != null)
				
					returnUrl = ExtractQueryParams(currentPath)["ReturnUrl"];

				if (Globals.IsNullorEmpty(returnUrl))
					return urlData.FormatUrl("login", CSContext.Current.RawUrl);
				else
					return urlData.FormatUrl("login", returnUrl);
			}
		}

		public virtual string Logout 
		{
			get { return urlData.FormatUrl("logout"); }
		}

		public virtual string Message (CSExceptionType exceptionType) 
		{
			return urlData.FormatUrl("message", ((int) exceptionType).ToString());
		}

		public virtual string Message (CSExceptionType exceptionType, string returnUrl) 
		{
			return urlData.FormatUrl("message_return", ((int) exceptionType).ToString(), returnUrl);
		}
		#endregion

		#region Voting
		public virtual string PollCreate (int sectionID) {
			return urlData.FormatUrl("poll",sectionID.ToString());
		}

		#endregion

        public virtual string GuestBook(string username)
        {
            Globals.ValidateApplicationKey(username,out username);
            username = Globals.UrlEncode(username);

            return urlData.FormatUrl("book_User", username);
        }

        public virtual string Redirect(string url)
        {
            return urlData.FormatUrl("redirect",Globals.UrlEncode(url));
        }

        public virtual string Home 
        { 
            get { return urlData.FormatUrl("home"); }
        }

		#region Forum / ForumGroup

		public virtual string ForumsHome 
		{ 
			get { return urlData.FormatUrl("forumshome"); }
		}





		public virtual string ForumGroup (int forumGroupID) 
		{
			return ForumGroup (forumGroupID, CSContext.Current.SiteSettings.EnableSearchFriendlyURLs);
		}

		public virtual string ForumGroup (int forumGroupID, bool searchFriendly) 
		{
			if (searchFriendly)
				return urlData.FormatUrl("searchFriendlyForumGroup", forumGroupID.ToString());
			else
				return urlData.FormatUrl("forumGroup", forumGroupID.ToString());
		}
		#endregion

		#region Private static helper methods

		public static string RemoveParameters (string url) 
		{

			if (url == null)
				return string.Empty;

			int paramStart = url.IndexOf("?");

			if (paramStart > 0)
				return url.Substring(0, paramStart);

			return url;
		}

		protected static NameValueCollection ExtractQueryParams(string url) 
		{
			int startIndex = url.IndexOf("?");
			NameValueCollection values = new NameValueCollection();

			if (startIndex <= 0)
				return values;

			string[] nameValues = url.Substring(startIndex + 1).Split('&');

			foreach (string s in nameValues) 
			{
				string[] pair = s.Split('=');

				string name = pair[0];
				string value = string.Empty;

				if (pair.Length > 1)
					value = pair[1];

				values.Add(name, value);
			}

			return values;
		}

		public static string FormatUrlWithParameters(string url, string parameters) 
		{
			if (url == null)
				return string.Empty;

			if (parameters.Length > 0)
				url = url + "?" + parameters;

			return url;

		}

		#endregion

		#region Public helper methods

        private static Regex ReWriteFilter = null;

        public static bool RewriteUrl(string path, string queryString, out string newPath)
        {
            
            //ReWriterFilter enables us to mark sections of the SiteUrls.config as non rewritable. This is particularly helpful
            //when moving the weblogs and gallery to the root of the site. Otherwise, there is a very likely chance /user /admin /utility
            // /search will be mistaken treated as a blog or gallery.
            if(ReWriteFilter == null)
                ReWriteFilter = new Regex(SiteUrls.Instance().LocationFilter, RegexOptions.IgnoreCase|RegexOptions.Compiled);

            //If we do not match a filter, continue one
            if(!ReWriteFilter.IsMatch(path))
            {
                //now, we walk through all of our ReWritable Urls and see if any match
            	ArrayList urls = SiteUrls.Instance().ReWrittenUrls;
                if(urls.Count > 0)
                {
                    foreach(ReWrittenUrl url in urls)
                    {
                        if(url.IsMatch(path))
                        {
                            newPath = url.Convert(path,queryString);
                            return true;
                        }
                    
                    }
                }
            }

            //Nothing found
            newPath = null;
            return false;
        }

		public struct ForumLocation 
		{
			public string Description;
			public string UrlName;
			public int ForumID;
			public int ForumGroupID;
			public int PostID;
			public int UserID;
		}

		public static ForumLocation GetForumLocation (string encodedLocation) 
		{

			// Decode the location
			ForumLocation location = new ForumLocation();
			string[] s = encodedLocation.Split(':');
			try 
			{
				location.UrlName        = s[0];
				location.ForumGroupID   = int.Parse(s[1]);
				location.ForumID        = int.Parse(s[2]);
				location.PostID         = int.Parse(s[3]);
				location.UserID         = int.Parse(s[4]);
			} 
			catch {}

			return location;

		}

        #region LocationKey
		// Takes a URL used in the forums and performs a reverse
		// lookup to return a friendly name of the currently viewed
		// resource
		//
		public static string LocationKey () 
		{
		    CSContext csContext = CSContext.Current;
			string url = csContext.RawUrl;
            
			if (Globals.ApplicationPath.Length > 0)
				url = url.Replace(Globals.ApplicationPath, "").ToLower();

			NameValueCollection reversePaths = Globals.GetSiteUrls().ReversePaths;
			int forumGroupIDqs = -1;
			int forumIDqs = -1;
			int postIDqs = -1;
			int userIDqs = -1;
			int modeIDqs = -1;

			// Modify the url so we can perform a reverse lookup
			//
			try 
			{
				for (int i = 0; i < csContext.Context.Request.QueryString.Count; i++) 
				{
					string key = csContext.Context.Request.QueryString.Keys[i].ToLower();

					switch (key) 
					{
						case "forumid":
							forumIDqs = int.Parse(csContext.Context.Request.QueryString[key]);
							break;
						case "postid":
							postIDqs = int.Parse(csContext.Context.Request.QueryString[key]);
							break;
						case "userid":
							userIDqs = int.Parse(csContext.Context.Request.QueryString[key]);
							break;
						case "forumgroupid":
							forumGroupIDqs = int.Parse(csContext.Context.Request.QueryString[key]);
							break;
						case "mode":
							modeIDqs = int.Parse(csContext.Context.Request.QueryString[key]);
							break;
					}
					url = url.Replace(csContext.Context.Request.QueryString[key], "{"+i+"}");
				}

			} 
			catch 
			{
				return "";
			}

			string retval = reversePaths[url];

			if ((retval == null) || (retval == string.Empty))
				retval = "/";

			return retval + ":" + forumGroupIDqs + ":" + forumIDqs + ":" + postIDqs + ":" + userIDqs + ":" + modeIDqs;


		}
		#endregion

        #endregion

		#region Public properties
		public bool EnableWaitPage 
		{
			get 
			{
				return true;
			}
			set 
			{
				enableWaitPage = value;
			}

		}

		public ArrayList TabUrls
		{
			get
			{
				return urlData.TabUrls;
			}
		}

        public virtual string LocationFilter
        {
            get
            {
                return urlData.LocationFilter;
            }
        }

        public SiteUrlsData UrlData
        {
            get{return urlData;}
        }

		public NameValueCollection ReversePaths 
		{
			get 
			{
				return urlData.ReversePaths;
			}
		}

        public ArrayList ReWrittenUrls
        {
            get
            {
                return urlData.ReWrittenUrls;
            }
        }

        public NameValueCollection Locations
        {
            get
            {
                return urlData.Locations;
            }
        }

		#endregion

    }

    #region ReWrittenUrl
    public class ReWrittenUrl
    {
        private string _name; 
        private string _path;
        private Regex _regex=null;
        
        public ReWrittenUrl(string name, string pattern, string path)
        {
            _name = name;
            _path = path;
            _regex = new Regex(pattern,RegexOptions.IgnoreCase | RegexOptions.Compiled);
        }

        public bool IsMatch(string url)
        {
            return _regex.IsMatch(url);
        }

        public virtual string Convert(string url, string qs)
        {
            if(qs != null && qs.StartsWith("?"))
            {
                qs = qs.Replace("?","&");
            }
            return string.Format("{0}{1}", _regex.Replace(url, _path),qs);
        }
    }
    #endregion
}