Exemple #1
0
 /// <summary>
 /// 获取绑定域名的频道分类目录名
 /// </summary>
 /// <param name="webPath">网站安装目录</param>
 /// <param name="requestPath">当前页面,包含目录</param>
 /// <param name="requestDomain">当前的域名(含端口号)</param>
 /// <returns>String</returns>
 private string GetDomainPath(string webPath, string requestPath, string requestDomain)
 {
     //获取绑定域名的目录
     if (SiteDomains.GetSiteDomains().CategoryDirs.ContainsValue(requestDomain))
     {
         return(SiteDomains.GetSiteDomains().Domains[requestDomain]);
     }
     return(string.Empty);
 }
Exemple #2
0
        /// <summary>
        /// 获取虚拟目录的频道分类目录名
        /// </summary>
        /// <param name="webPath">网站安装目录</param>
        /// <param name="requestPath">当前页面,包含目录</param>
        /// <param name="requestDomain">当前的域名(含端口号)</param>
        /// <returns>String</returns>
        private string GetCategoryPath(string webPath, string requestPath, string requestDomain)
        {
            //获取URL的虚拟目录(除安装目录)
            string requestFirstPath = GetFirstPath(webPath, requestPath);

            if (requestFirstPath != string.Empty && SiteDomains.GetSiteDomains().CategoryDirs.ContainsKey(requestFirstPath))
            {
                return(requestFirstPath);
            }
            return(string.Empty);
        }
Exemple #3
0
        /// <summary>
        /// 获取访问的频道分类目录(不含安装目录)
        /// </summary>
        private string GetFirstPath()
        {
            string requestPath = HttpContext.Current.Request.CurrentExecutionFilePath.ToLower(); //获得当前页面虚拟路径
            int    indexNum    = config.webpath.Length;                                          //安装目录长度

            //如果包含安装目录和aspx目录也要过滤掉
            if (requestPath.StartsWith(config.webpath + MXKeys.DIRECTORY_REWRITE_ASPX + "/"))
            {
                indexNum = (config.webpath + MXKeys.DIRECTORY_REWRITE_ASPX + "/").Length;
            }
            string requestFirstPath = requestPath.Substring(indexNum);

            if (requestFirstPath.IndexOf("/") > 0)
            {
                requestFirstPath = requestFirstPath.Substring(0, requestFirstPath.IndexOf("/"));
            }
            if (requestFirstPath != string.Empty && SiteDomains.GetSiteDomains().CategoryDirs.ContainsKey(requestFirstPath))
            {
                return(requestFirstPath);
            }
            return(string.Empty);
        }
Exemple #4
0
        /// <summary>
        /// 返回URL重写统一链接地址
        /// </summary>
        public string linkurl(string _key, params object[] _params)
        {
            Hashtable ht = new BLL.url_rewrite().GetList();          //获得URL配置列表

            Model.url_rewrite model = ht[_key] as Model.url_rewrite; //查找指定的URL配置节点

            //如果不存在该节点则返回空字符串
            if (model == null)
            {
                return(string.Empty);
            }

            string requestDomain    = HttpContext.Current.Request.Url.Authority.ToLower(); //获得来源域名含端口号
            string requestFirstPath = GetFirstPath();                                      //获得二级目录(不含站点安装目录)
            string linkStartString  = string.Empty;                                        //链接前缀

            //检查是否与绑定的域名或者与默认频道分类的目录匹配
            if (SiteDomains.GetSiteDomains().CategoryDirs.ContainsValue(requestDomain))
            {
                linkStartString = "/";
            }

            else if (requestFirstPath == string.Empty || requestFirstPath == SiteDomains.GetSiteDomains().DefaultPath)
            {
                linkStartString = config.webpath;
            }
            else
            {
                linkStartString = config.webpath + requestFirstPath + "/";
            }
            //如果URL字典表达式不需要重写则直接返回
            if (model.url_rewrite_items.Count == 0)
            {
                //检查网站重写状态
                if (config.staticstatus > 0)
                {
                    if (_params.Length > 0)
                    {
                        return(linkStartString + GetUrlExtension(model.page, config.staticextension) + string.Format("{0}", _params));
                    }
                    else
                    {
                        return(linkStartString + GetUrlExtension(model.page, config.staticextension));
                    }
                }
                else
                {
                    if (_params.Length > 0)
                    {
                        return(linkStartString + model.page + string.Format("{0}", _params));
                    }
                    else
                    {
                        return(linkStartString + model.page);
                    }
                }
            }
            //否则检查该URL配置节点下的子节点
            foreach (Model.url_rewrite_item item in model.url_rewrite_items)
            {
                //如果参数个数匹配
                if (IsUrlMatch(item, _params))
                {
                    //检查网站重写状态
                    if (config.staticstatus > 0)
                    {
                        return(linkStartString + string.Format(GetUrlExtension(item.path, config.staticextension), _params));
                    }
                    else
                    {
                        string queryString = Regex.Replace(string.Format(item.path, _params), item.pattern, item.querystring, RegexOptions.None | RegexOptions.IgnoreCase);
                        if (queryString.Length > 0)
                        {
                            queryString = "?" + queryString;
                        }
                        return(linkStartString + model.page + queryString);
                    }
                }
            }

            return(string.Empty);
        }
Exemple #5
0
        /// <summary>
        /// 页面请求事件处理
        /// </summary>
        /// <param name="sender">事件的源</param>
        /// <param name="e">包含事件数据的 EventArgs</param>
        private void ReUrl_BeginRequest(object sender, EventArgs e)
        {
            HttpContext context       = ((HttpApplication)sender).Context;
            string      requestDomain = context.Request.Url.Authority.ToLower(); //获得当前域名(含端口号)
            string      requestPath   = context.Request.Path.ToLower();          //获得当前页面(含目录)

            Model.siteconfig siteConfig = new BLL.siteconfig().loadConfig();     //获得站点配置信息

            //如果虚拟目录(不含安装目录)与站点根目录名相同则不需要重写
            if (IsDirExist(MXKeys.CACHE_SITE_DIRECTORY, siteConfig.webpath, siteConfig.webpath, requestPath))
            {
                return;
            }

            //检查网站重写状态0表示不开启重写、1开启重写、2生成静态
            if (siteConfig.staticstatus == 0)
            {
                #region 站点不开启重写处理方法=======================================
                ////遍历URL字典,匹配URL页面部分
                //foreach (Model.url_rewrite model in SiteUrls.GetSiteUrls().Urls)
                //{
                //    //查找到与页面部分匹配的节点
                //    if (model.page == requestPath.Substring(requestPath.LastIndexOf("/") + 1))
                //    {
                //        //如果该页面属于插件页则映射到插件目录,否则映射到频道分类目录
                //        if (model.type == MXKeys.DIRECTORY_REWRITE_PLUGIN)
                //        {
                //            context.RewritePath(string.Format("{0}{1}/{2}{3}",
                //                siteConfig.webpath, MXKeys.DIRECTORY_REWRITE_ASPX, MXKeys.DIRECTORY_REWRITE_PLUGIN, requestPath));
                //            return;
                //        }
                //        else
                //        {
                //            ////默认的频道目录
                //            string defaultPath = SiteDomains.GetSiteDomains().DefaultPath;
                //            //获取绑定域名的频道分类目录
                //            string domainPath = GetDomainPath(siteConfig.webpath, requestPath, requestDomain);
                //            //获取虚拟目录的频道分类目录
                //            string categoryPath = GetCategoryPath(siteConfig.webpath, requestPath, requestDomain);
                //            if (domainPath != string.Empty)
                //            {
                //                defaultPath = domainPath;
                //            }
                //            else if (categoryPath != string.Empty)
                //            {
                //                defaultPath = categoryPath;
                //            }

                //            context.RewritePath(string.Format("{0}{1}/{2}{3}",
                //                siteConfig.webpath, MXKeys.DIRECTORY_REWRITE_ASPX, defaultPath, requestPath));
                //            return;
                //        }
                //    }
                //}
                #endregion
            }
            else
            {
                #region 站点开启重写或静态处理方法===================================
                ////默认的频道目录
                string defaultPath = SiteDomains.GetSiteDomains().DefaultPath;
                //获取绑定域名的频道分类目录
                string domainPath = GetDomainPath(siteConfig.webpath, requestPath, requestDomain);
                //获取虚拟目录的频道分类目录
                string categoryPath = GetCategoryPath(siteConfig.webpath, requestPath, requestDomain);

                //遍历URL字典
                foreach (Model.url_rewrite model in SiteUrls.GetSiteUrls().Urls)
                {
                    //如果没有重写表达式则不需要重写
                    if (model.url_rewrite_items.Count == 0 &&
                        Utils.GetUrlExtension(model.page, siteConfig.staticextension) == requestPath.Substring(requestPath.LastIndexOf("/") + 1))
                    {
                        //如果该页面属于插件页则映射到插件目录,否则映射到频道分类目录
                        if (model.type == MXKeys.DIRECTORY_REWRITE_PLUGIN)
                        {
                            context.RewritePath(string.Format("{0}{1}/{2}/{3}",
                                                              siteConfig.webpath, MXKeys.DIRECTORY_REWRITE_ASPX, MXKeys.DIRECTORY_REWRITE_PLUGIN, model.page));
                            return;
                        }
                        else
                        {
                            if (domainPath == string.Empty)
                            {
                                domainPath = SiteDomains.GetSiteDomains().DefaultPath; //默认的频道目录
                            }
                            context.RewritePath(string.Format("{0}{1}/{2}/{3}", siteConfig.webpath, MXKeys.DIRECTORY_REWRITE_ASPX, domainPath, model.page));
                            return;
                        }
                    }
                    //遍历URL字典的子节点
                    foreach (Model.url_rewrite_item item in model.url_rewrite_items)
                    {
                        if (domainPath != string.Empty)
                        {
                            defaultPath = domainPath; //如果是绑定的域名访问则将对应的目录赋值
                        }
                        else if (categoryPath != string.Empty)
                        {
                            defaultPath = categoryPath; //如果是虚拟目录访问则将对应的目录赋值
                        }
                        string patternPath = siteConfig.webpath;
                        if (domainPath == string.Empty && categoryPath != string.Empty)
                        {
                            patternPath += categoryPath + "/";
                        }
                        string newPattern = Utils.GetUrlExtension(item.pattern, siteConfig.staticextension); //替换扩展名

                        //如果与URL节点匹配则重写
                        if (Regex.IsMatch(requestPath, string.Format("^{0}{1}$", patternPath, newPattern), RegexOptions.None | RegexOptions.IgnoreCase) ||
                            (model.page == "index.aspx" && Regex.IsMatch(requestPath, string.Format("^{0}{1}$", patternPath, item.pattern), RegexOptions.None | RegexOptions.IgnoreCase)))
                        {
                            //如果开启生成静态、不是手机网站且是频道页或首页,则映射重写到HTML目录
                            if (siteConfig.staticstatus == 2 && defaultPath != MXKeys.DIRECTORY_REWRITE_MOBILE &&
                                (model.channel.Length > 0 || model.page.ToLower() == "index.aspx")) //频道页
                            {
                                if (domainPath == string.Empty && categoryPath != string.Empty)
                                {
                                    context.RewritePath(siteConfig.webpath + MXKeys.DIRECTORY_REWRITE_HTML + Utils.GetUrlExtension(requestPath, siteConfig.staticextension, true));
                                }
                                else
                                {
                                    context.RewritePath(siteConfig.webpath + MXKeys.DIRECTORY_REWRITE_HTML + "/" + defaultPath + Utils.GetUrlExtension(requestPath, siteConfig.staticextension, true));
                                }
                                return;
                            }
                            else if (model.type == MXKeys.DIRECTORY_REWRITE_PLUGIN) //插件页
                            {
                                string queryString = Regex.Replace(requestPath, string.Format("{0}{1}", patternPath, newPattern),
                                                                   item.querystring, RegexOptions.None | RegexOptions.IgnoreCase);
                                context.RewritePath(string.Format("{0}{1}/{2}/{3}", siteConfig.webpath, MXKeys.DIRECTORY_REWRITE_ASPX, MXKeys.DIRECTORY_REWRITE_PLUGIN, model.page),
                                                    string.Empty, queryString);
                                return;
                            }
                            else //其它
                            {
                                string queryString = Regex.Replace(requestPath, string.Format("{0}{1}", patternPath, newPattern),
                                                                   item.querystring, RegexOptions.None | RegexOptions.IgnoreCase);
                                context.RewritePath(string.Format("{0}{1}/{2}/{3}",
                                                                  siteConfig.webpath, MXKeys.DIRECTORY_REWRITE_ASPX, defaultPath, model.page), string.Empty, queryString);
                                return;
                            }
                        }
                    }
                }
                #endregion
            }
        }