C# ContentItem.FindPath方法代码示例

        /// <summary>Calculates an item url by walking it's parent path.</summary>
        /// <param name="item">The item whose url to compute.</param>
        /// <returns>A friendly url to the supplied item.</returns>
        public override string BuildUrl(ContentItem item)
        {
            if (item == null) throw new ArgumentNullException("item");

            ContentItem current = item;

            if (item.VersionOf.HasValue)
            {
                current = item.VersionOf;
            }

            // move up until first real page
            while(current != null && !current.IsPage)
            {
                current = current.Parent;
            }

            // no start page found, use rewritten url
            if (current == null) return item.FindPath(PathData.DefaultAction).GetRewrittenUrl();

            Url url;
            if (host.IsStartPage(current))
            {
                // we move right up to the start page
                url = "/";
            }
            else
            {
                // at least one node before the start page
                url = new Url("/" + current.Name + current.Extension);
                current = current.Parent;
                // build path until a start page
                while (current != null && !host.IsStartPage(current))
                {
                    url = url.PrependSegment(current.Name);
                    current = current.Parent;
                }
            }

            // no start page found, use rewritten url
            if (current == null) return item.FindPath(PathData.DefaultAction).GetRewrittenUrl();

            if (item.IsPage && item.VersionOf.HasValue)
                // the item was a version, add this information as a query string
                url = url.AppendQuery(PathData.PageQueryKey, item.ID);
            else if(!item.IsPage)
                // the item was not a page, add this information as a query string
                url = url.AppendQuery(PathData.ItemQueryKey, item.ID);

            if (current.ID == host.CurrentSite.StartPageID)
            {
                // the start page belongs to the current site, use relative url
                return Url.ToAbsolute("~" + url.PathAndQuery);
            }

            var site = host.GetSite(current.ID) ?? host.DefaultSite;

            return GetHostedUrl(item, url, site);
        }

        protected override string GetPreviewUrl(ContentItem item)
        {
            if (item.VersionOf == null)
                return item.Url;

            return Url.Parse(item.FindPath(PathData.DefaultAction).RewrittenUrl)
                .AppendQuery("preview", item.ID)
                .AppendQuery("original", item.VersionOf.ID);
        }

		/// <summary>Gets the url for the preview frame.</summary>
		/// <param name="selectedItem">The currently selected item.</param>
		/// <returns>An url.</returns>
		public virtual string GetPreviewUrl(ContentItem selectedItem)
		{
			try
			{
				// If hostname == localhost, then don't use custom hostnames in the management navigation tree
				if (HttpContext.Current != null && HttpContext.Current.Request.Url.Host == "localhost")
					return selectedItem.FindPath(PathData.DefaultAction).GetRewrittenUrl();

				Url url = ResolveResourceUrl(parser.BuildUrl(selectedItem));
				return url;
			}
			catch (N2Exception)
			{
				return Url.ResolveTokens("{ManagementUrl}/Empty.aspx?item=" + selectedItem.ID);
			}
		}

		/// <summary>Calculates an item url by walking it's parent path.</summary>
		/// <param name="item">The item whose url to compute.</param>
		/// <returns>A friendly url to the supplied item.</returns>
		public override Url BuildUrl(ContentItem item)
		{
			if (item == null) throw new ArgumentNullException("item");

			if (item.VersionOf.HasValue && item.VersionOf.Value != null)
			{
				return BuildUrl(item.VersionOf.Value)
					.SetQueryParameter(PathData.VersionIndexQueryKey, item.VersionIndex);
			}
			else if (item.ID == 0)
			{
				var page = Find.ClosestPage(item);
				if (page != null && page != item)
				{
					return BuildUrl(page)
						.SetQueryParameter(PathData.VersionIndexQueryKey, page.VersionIndex)
						.SetQueryParameter("versionKey", item.GetVersionKey());
				}
			}

			// move up until first real page
			var current = Find.ClosestPage(item);

			// no page found, throw
			if (current == null) throw new N2Exception("Cannot build url to data item '{0}' with no containing page item.", item);

			Url url = BuildPageUrl(current, ref current);

			var startPage = FindStartPage(current);
			// no start page found, use rewritten url
			if (startPage == null)
				return item.FindPath(PathData.DefaultAction).GetRewrittenUrl();

			if (!item.IsPage)
				// the item was not a page, add this information as a query string
				url = url.AppendQuery(PathData.ItemQueryKey, item.ID);

			if (startPage.ID == host.CurrentSite.StartPageID)
            {
                // the start page belongs to the current site, use relative url
            	return Url.ToAbsolute("~" + url.PathAndQuery);
            }

			var site = host.GetSite(startPage.ID) ?? host.DefaultSite;

            return GetHostedUrl(item, url, site);
        }

		public override PathData ResolvePath(ContentItem startingPoint, string path)
		{
			return startingPoint.FindPath(path);
		}

		/// <summary>Gets the path to the given item's template. This is a way to override the default template provided by the content item.</summary>
		/// <param name="item">The item whose path is requested.</param>
		/// <returns>The virtual path of the template or null if the item is not supposed to be added.</returns>
		protected virtual string GetTemplateUrl(ContentItem item)
		{
			return item.FindPath(PathData.DefaultAction).TemplateUrl;
		}

        private static string GetHostedUrl(ContentItem item, string url, Site site)
        {
            string hostName = site.GetHostName(item.Language);
            if (string.IsNullOrEmpty(hostName))
                return item.FindPath(PathData.DefaultAction).RewrittenUrl;

            return Url.Parse(url).SetAuthority(hostName);
        }

        /// <summary>Calculates an item url by walking it's parent path.</summary>
        /// <param name="item">The item whose url to compute.</param>
        /// <returns>A friendly url to the supplied item.</returns>
        public virtual string BuildUrl(ContentItem item)
        {
            if (item == null) throw new ArgumentNullException("item");

            ContentItem current = item;

            if (item.VersionOf != null)
            {
                current = item.VersionOf;
            }

            // move up until first real page
            while (current != null && !current.IsPage)
            {
                current = current.Parent;
            }

            // no page found, use rewritten url
            if (current == null) throw new N2Exception("Cannot build url to data item '{0}' with no containing page item.", item);

            Url url;
            if (host.IsStartPage(current))
            {
                // we move right up to the start page
                url = "/";
            }
            else
            {
                // at least one node before the start page
                url = new Url("/" + current.Name + current.Extension);
                current = current.Parent;
                // build path until a start page
                while (current != null && !host.IsStartPage(current))
                {
                    url = url.PrependSegment(current.Name);
                    current = current.Parent;
                }
            }

            // no start page found, use rewritten url
            if (current == null) return item.FindPath(PathData.DefaultAction).RewrittenUrl;

            if (item.IsPage && item.VersionOf != null)
                // the item was a version, add this information as a query string
                url = url.AppendQuery(PathData.PageQueryKey, item.ID);
            else if (!item.IsPage)
                // the item was not a page, add this information as a query string
                url = url.AppendQuery(PathData.ItemQueryKey, item.ID);

            return Url.ToAbsolute("~" + url);
        }

        private string GetHostedUrl(ContentItem item, string url, Site site)
        {
            if (string.IsNullOrEmpty(site.Authority))
                return item.FindPath(PathData.DefaultAction).GetRewrittenUrl();

            return Url.Parse(url).SetAuthority(site.Authority);
        }

        /// <summary>Gets the url to the edit page where to edit an existing item.</summary>
        /// <param name="item">The item to edit.</param>
        /// <returns>The url to the edit page</returns>
        public virtual string GetEditExistingItemUrl(ContentItem item)
        {
            if (item == null)
                return null;

            string editUrl = Url.ResolveTokens(EditItemUrl);
            if (item.VersionOf != null)
                return string.Format("{0}?selectedUrl={1}", editUrl,
                                     HttpUtility.UrlEncode(item.FindPath(PathData.DefaultAction).RewrittenUrl));

            return Url.Parse(editUrl).AppendQuery("selected", item.Path);
        }

        protected virtual void RegisterRefreshNavigationScript(ContentItem item)
        {
            string script = string.Format(refreshScriptFormat,
                VirtualPathUtility.ToAbsolute(Engine.ManagementPaths.ResolveResourceUrl("{ManagementUrl}/Content/Default.aspx")), // 0
                GetNavigationUrl(item), // 1
                item.ID, // 2
                item.FindPath(PathData.DefaultAction).RewrittenUrl, // 3
                item.Path // 4
                );

            ClientScript.RegisterClientScriptBlock(
                typeof(Default),
                "AddRefreshEditScript",
                script, true);
        }

		/// <summary>Calculates an item url by walking it's parent path.</summary>
		/// <param name="item">The item whose url to compute.</param>
		/// <returns>A friendly url to the supplied item.</returns>
		public virtual Url BuildUrl(ContentItem item)
		{
			if (item == null) throw new ArgumentNullException("item");

			if (item.VersionOf.HasValue)
			{
				ContentItem version = item.VersionOf;
				if (version != null)
					return BuildUrl(version).SetQueryParameter(PathData.VersionIndexQueryKey, item.VersionIndex);
			}
			else if (item.ID == 0)
			{
				var page = Find.ClosestPage(item);
				if (page != null && page != item)
				{
					return BuildUrl(page)
						.SetQueryParameter(PathData.VersionIndexQueryKey, page.VersionIndex)
						.SetQueryParameter("versionKey", item.GetVersionKey());
				}
			}

			var current = Find.ClosestPage(item);

			// no page found, throw
			if (current == null) throw new N2Exception("Cannot build url to data item '{0}' with no containing page item.", item);

			Url url = BuildPageUrl(current, ref current);

			if (current == null)
				// no start page found, use rewritten url
				return item.FindPath(PathData.DefaultAction).GetRewrittenUrl();

			if (!item.IsPage)
				// the item was not a page, add this information as a query string
				url = url.AppendQuery(PathData.ItemQueryKey, item.ID);

			var absoluteUrl = Url.ToAbsolute("~" + url);
			if (BuiltUrl != null)
			{
				var args = new UrlEventArgs(item) { Url = absoluteUrl };
				BuiltUrl(this, args);
				return args.Url;
			}
			else
				return absoluteUrl;
		}

 public override string GetPreviewUrl(ContentItem item)
 {
     return item.FindPath(PathData.DefaultAction).GetRewrittenUrl();
 }

        /// <summary>Gets the url to the edit page where to edit an existing item.</summary>
        /// <param name="item">The item to edit.</param>
        /// <param name="language">The language to edit (or create if it doesn't exist).</param>
        /// <returns>The url to the edit page</returns>
        public string GetEditExistingItemUrl(ContentItem item, string languageCode)
        {
            if (item == null)
                return null;

            if (string.IsNullOrEmpty(languageCode))
                languageCode = item.Language;

            if (item.VersionOf != null)
                return string.Format("{0}?selectedUrl={1}&language={2}", EditItemUrl, HttpUtility.UrlEncode(item.FindPath(PathData.DefaultAction).RewrittenUrl), languageCode);

            return string.Format("{0}?selected={1}&language={2}", EditItemUrl, item.Path, languageCode);
        }