private static IEnumerable <XElement> ExecuteInternal() { // Grab all active languages... foreach (CultureInfo culture in DataLocalizationFacade.ActiveLocalizationCultures) { XElement annotatedMatch; // enter the 'data scope' of the next language using (new DataScope(culture)) { // fetch sitemap element for current page - if any IPage match = PageManager.GetPageById(PageRenderer.CurrentPageId); if (match == null) { continue; } annotatedMatch = new XElement("LanguageVersion" , new XAttribute("Culture", culture.Name) , new XAttribute("CurrentCulture", culture.Equals(Thread.CurrentThread.CurrentCulture)) , new XAttribute("Id", match.Id) , new XAttribute("Title", match.Title) , (match.MenuTitle == null ? null : new XAttribute("MenuTitle", match.MenuTitle)) , new XAttribute("UrlTitle", match.UrlTitle) , new XAttribute("Description", match.Description) , new XAttribute("URL", PageUrls.BuildUrl(match)) ); } yield return(annotatedMatch); } }
public EntityToken TryGetEntityToken(string url) { UrlKind urlKind; PageUrlData pageUrlData = PageUrls.ParseUrl(url, out urlKind); if (pageUrlData == null) { return(null); } if (pageUrlData.PublicationScope == PublicationScope.Published) { pageUrlData.PublicationScope = PublicationScope.Unpublished; } if (!string.IsNullOrEmpty(pageUrlData.PathInfo) || pageUrlData.HasQueryParameters) { IData data; var dataReference = DataUrls.TryGetData(pageUrlData); if (dataReference != null && (data = dataReference.Data) != null) { return(data.GetDataEntityToken()); } } IPage page = pageUrlData.GetPage(); if (page == null) { return(null); } return(page.GetDataEntityToken()); }
public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection) { var path = httpContext.Request.Path; var pageUrlData = PageUrls.ParseUrl(path); if (pageUrlData == null) { return(false); } var routeData = _routeInfo.GetRouteData(new Uri("http://c1pathinfo" + pageUrlData.PathInfo)); if (routeData == null) { return(false); } foreach (var key in routeData.Values.Keys) { values.Add(key, routeData.Values[key]); } return(true); }
void ConsumerDbContext() { while (flagDB) { while (!dicitonaryOfCrawledUrls.IsEmpty) { Thread.Sleep(2000); if (cancelTicket) { break; } if (Helper.CountForSave(urlsForDBSaving) != 0) { PageUrls[] items = new PageUrls[Helper.CountForSave(urlsForDBSaving)]; Helper.RemoveFromDict(items, dicitonaryOfCrawledUrls, urlsForDBSaving); Helper.AddHostConnection(items, urlsForDBSaving, hosts, measures, _repo); _repo.AddPageOrUpdate(items.ToList()); logger.Trace("Save or update to DB " + items.Length + " pages"); } flagDB = false; } if (cancelTicket) { break; } } Clear(); logger.Trace("Finish DB"); }
/// <exclude /> public static Control Render(this IPage page, IEnumerable <IPagePlaceholderContent> placeholderContents, FunctionContextContainer functionContextContainer) { Verify.ArgumentNotNull(page, "page"); Verify.ArgumentNotNull(functionContextContainer, "functionContextContainer"); Verify.ArgumentCondition(functionContextContainer.XEmbedableMapper is XEmbeddedControlMapper, "functionContextContainer", $"Unknown or missing XEmbedableMapper on context container. Use {nameof(GetPageRenderFunctionContextContainer)}()."); CurrentPage = page; using (GlobalInitializerFacade.CoreIsInitializedScope) { string url = PageUrls.BuildUrl(page); using (TimerProfilerFacade.CreateTimerProfiler(url ?? "(no url)")) { var cultureInfo = page.DataSourceId.LocaleScope; System.Threading.Thread.CurrentThread.CurrentCulture = cultureInfo; System.Threading.Thread.CurrentThread.CurrentUICulture = cultureInfo; XEmbeddedControlMapper mapper = (XEmbeddedControlMapper)functionContextContainer.XEmbedableMapper; XDocument document = TemplateInfo.GetTemplateDocument(page.TemplateId); ResolvePlaceholders(document, placeholderContents); Control c = Render(document, functionContextContainer, mapper, page); return(c); } } }
public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection) { var path = httpContext.Request.Path; var pageUrlData = PageUrls.ParseUrl(path); if (pageUrlData == null) { return(false); } using (new DataScope(pageUrlData.PublicationScope, pageUrlData.LocalizationScope)) { var page = PageManager.GetPageById(pageUrlData.PageId); if (!_templateIds.Contains(page.TemplateId)) { return(false); } var template = PageTemplateFacade.GetPageTemplate(page.TemplateId) as MvcPageTemplateDescriptor; return(template != null); } }
public PageUrls TakeMesuares(string fullUrl) { var res = new PageUrls(); var webGet = new HtmlWeb(); try { _timeSpan.Start(); var document = webGet.Load(fullUrl); _timeSpan.Stop(); var loadTime = _timeSpan.Elapsed.Milliseconds; string html = document.DocumentNode.OuterHtml; byte[] toBytes = Encoding.ASCII.GetBytes(html); int x = toBytes.Length; int htmlSize = System.Text.ASCIIEncoding.Unicode.GetByteCount(html); var cssLinksHrefs = GetCssLinksHrefs(document); var imgSources = GetImgSources(document); var urlsInternal = GetUrlsInternal(GetHrefs(document, fullUrl), fullUrl); var urlsExternal = GetUrlsExtrnal(GetHrefs(document, fullUrl), fullUrl); res.Url = fullUrl; res.InternalUrls = urlsInternal; res.ExternalUrls = urlsExternal; res.LoadTime = loadTime; res.HtmlSize = htmlSize; res.CssLinks = cssLinksHrefs; res.ImgSources = imgSources; return(res); } catch (Exception e) { logger.Error(fullUrl + e.Message + e.InnerException); res.Url = fullUrl; return(res); } }
private static void HandleRootRequestInClassicMode(HttpContext httpContext) { if (HttpRuntime.UsingIntegratedPipeline) { return; } // Resolving root path "/" for classic mode string rawUrl = httpContext.Request.RawUrl; string rootPath = UrlUtils.PublicRootPath + (UrlUtils.PublicRootPath.EndsWith("/") ? "" : "/"); string defaultAspxPath = rootPath + "default.aspx"; if (rawUrl.StartsWith(defaultAspxPath, StringComparison.InvariantCultureIgnoreCase)) { string query = rawUrl.Substring(defaultAspxPath.Length); string shorterQuery = rootPath + query; // Checking that there's a related page) if (PageUrls.ParseUrl(shorterQuery) != null) { httpContext.RewritePath(shorterQuery); } } }
public PageInteraction(IE browser) { _browser = browser; _pageUrls = new PageUrls(); ScenarioContext.Current["username"] = username; ScenarioContext.Current["password"] = password; }
private SearchDocument FromPage(IPage page, EntityToken entityToken, Dictionary <Tuple <Guid, Guid>, List <IData> > allMetaData) { string label = page.MenuTitle; if (string.IsNullOrWhiteSpace(label)) { label = page.Title; } bool isPublished = page.DataSourceId.PublicationScope == PublicationScope.Published; string documentId = GetDocumentId(page); var docBuilder = new SearchDocumentBuilder(_docBuilderExtensions); docBuilder.SetDataType(typeof(IPage)); docBuilder.CrawlData(page); using (new DataConnection(page.DataSourceId.PublicationScope, page.DataSourceId.LocaleScope)) { if (isPublished) { docBuilder.Url = PageUrls.BuildUrl(page, UrlKind.Internal); } var placeholders = PageManager.GetPlaceholderContent(page.Id, page.VersionId); placeholders.ForEach(pl => docBuilder.CrawlData(pl, true)); List <IData> metaData; if (allMetaData != null) { allMetaData.TryGetValue(new Tuple <Guid, Guid>(page.Id, page.VersionId), out metaData); } else { metaData = GetMetaData(page.Id, page.VersionId, page.DataSourceId.PublicationScope, page.DataSourceId.LocaleScope); } try { metaData?.ForEach(pageMetaData => docBuilder.CrawlData(pageMetaData)); } catch (Exception ex) { Log.LogWarning(LogTitle, ex); } } if (!string.IsNullOrEmpty(page.UrlTitle) && !UrlFormattersPluginFacade.FormatUrl(page.Title, true).Equals(page.UrlTitle, StringComparison.OrdinalIgnoreCase) && !UrlFormattersPluginFacade.FormatUrl(page.Title, false).Equals(page.UrlTitle, StringComparison.OrdinalIgnoreCase)) { docBuilder.TextParts.Add(page.UrlTitle); } return(docBuilder.BuildDocument(Name, documentId, label, null, entityToken)); }
public string TryGetUrl(EntityToken entityToken) { var groupingEntityToken = entityToken as TreeDataFieldGroupingElementEntityToken; if (groupingEntityToken != null && groupingEntityToken.Source == BlogTreeSource) { object dateTimeObject; if (groupingEntityToken.ChildGeneratingDataElementsReferenceType == typeof(IPage) && groupingEntityToken.DeserializedGroupingValues.TryGetValue("Date", out dateTimeObject)) { var pageId = (Guid)groupingEntityToken.ChildGeneratingDataElementsReferenceValue; var page = PageManager.GetPageById(pageId); if (page == null) { return(null); } var date = (DateTime)dateTimeObject; string pathInfo = $"/{date.Year}/{date.Month}"; return(PageUrls.BuildUrl(new PageUrlData(page) { PathInfo = pathInfo }, UrlKind.Public, new UrlSpace { ForceRelativeUrls = true })); } return(null); } var treeElementEntityToken = entityToken as TreeSimpleElementEntityToken; if (treeElementEntityToken != null && treeElementEntityToken.Source == BlogTreeSource && treeElementEntityToken.Id == "Root") { var parentEntityToken = treeElementEntityToken.ParentEntityToken; var dataParent = parentEntityToken as DataEntityToken; if (dataParent != null && dataParent.InterfaceType == typeof(IPage)) { var page = dataParent.Data as IPage; if (page != null) { return(PageUrls.BuildUrl(new PageUrlData(page), UrlKind.Public, new UrlSpace { ForceRelativeUrls = true })); } } } return(null); }
private static string GetPagePreviewUrl(PageUrlData pageUrlData) { var urlSpace = new UrlSpace { ForceRelativeUrls = true }; return(PageUrls.BuildUrl(pageUrlData, UrlKind.Public, urlSpace) ?? PageUrls.BuildUrl(pageUrlData, UrlKind.Renderer, urlSpace)); }
public static Dictionary <string, Guid> GetMappingsFromSiteMap() { var result = new Dictionary <string, Guid>(); var urlSpace = new UrlSpace(); // TODO: support for multiple languages as well var hostnameBindings = DataFacade.GetData <IHostnameBinding>().ToList(); var rootToHostnameMap = hostnameBindings.ToDictionary(h => h.HomePageId, h => h.Hostname); foreach (var cultureInfo in DataLocalizationFacade.ActiveLocalizationCultures.ToArray()) { using (new DataScope(DataScopeIdentifier.Public, cultureInfo)) { var pages = DataFacade.GetData <IPage>().ToList(); foreach (var page in pages) { var url = PageUrls.BuildUrl(new PageUrlData(page), UrlKind.Public, urlSpace); if (url != null && !result.ContainsKey(url)) { result.Add(url, page.Id); } var rootPageId = GetRootPageId(page.Id); string hostname; if (rootToHostnameMap.TryGetValue(rootPageId, out hostname)) { if (urlSpace.Hostname != hostname) { var hostnameBasedUrlSpace = new UrlSpace { ForceRelativeUrls = false, Hostname = hostname }; url = PageUrls.BuildUrl(new PageUrlData(page), UrlKind.Public, hostnameBasedUrlSpace); } if (url != null) { if (url.StartsWith("/")) { url = "http://{0}{1}".FormatWith(hostname, url); } if (!result.ContainsKey(url)) { result.Add(url, page.Id); } } } } } } return(result); }
/// <summary> /// Initializes a new instance of the <see cref="CmsPageSiteMapNode"/> class. /// </summary> /// <param name="provider">The provider.</param> /// <param name="page">The page.</param> public CmsPageSiteMapNode(SiteMapProvider provider, IPage page) : base(provider, page.Id.ToString(), PageUrls.BuildUrl(page), page.MenuTitle, page.Description) { Page = page; DocumentTitle = page.Title; LastModified = page.ChangeDate; Priority = 5; Culture = page.DataSourceId.LocaleScope; }
/// <summary> /// Returns localized URL. It was changed from original implementation to fix 6520: Previewing unpublished category pages is C1 console shows error in the preview, and on frontend once the page is published /// </summary> /// <param name="pageId"></param> /// <param name="cultureInfo"></param> /// <returns></returns> public virtual string GetRendererPageUrl(Guid pageId, CultureInfo cultureInfo = null) { if (cultureInfo == null) { cultureInfo = DataLocalizationFacade.DefaultLocalizationCulture; } var pageUrlData = new PageUrlData(pageId, PublicationScope.Published, cultureInfo); return(PageUrls.BuildUrl(pageUrlData, UrlKind.Renderer)); }
public static PageUrlData GetPageUrlDataFromUrl(string urlStr) { PageUrlData pageUrlData = null; while (pageUrlData == null && urlStr.LastIndexOf('/') > 0) { urlStr = urlStr.Substring(0, urlStr.LastIndexOf('/')); pageUrlData = PageUrls.ParseUrl(urlStr); } return(pageUrlData); }
public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection) { var path = httpContext.Request.Path; var pageUrlData = PageUrls.ParseUrl(path); if (pageUrlData == null) { return(false); } return(pageUrlData.PageId == _pageId); }
private void CrawlUrls(PageUrls resultOfmeasure) { CrawlInternalUrls(resultOfmeasure); CrawlExternalUrls(resultOfmeasure); if (cancelTicket) { return; } if (!urlsForDBSaving.ContainsKey(resultOfmeasure.Url)) { urlsForDBSaving.TryAdd(resultOfmeasure.Url, false); } }
/// <summary> /// Returns a public url to the specified data item key. /// </summary> /// <param name="key">The key value.</param> /// <returns></returns> public virtual string ItemUrl(object key) { var data = DataFacade.GetDataByUniqueKey <T>(key); if (data == null) { return(null); } var mapper = GetUrlMapper(); return(PageUrls.BuildUrl(mapper.BuildItemUrl(data))); }
/// <summary> /// Looks for a friendly URL and set pageUrl if found. /// </summary> /// <param name="relativeUrl">The string to match to a friendly URL</param> /// <param name="pageUrl">The matching page, if a match was found. Otherwise null.</param> /// <returns>True if a friendly URL match was found</returns> public static bool TryParseFriendlyUrl(string relativeUrl, out PageUrl pageUrl) { UrlKind urlKind; PageUrlData pageUrlData = PageUrls.ParseUrl(relativeUrl, new UrlSpace(), out urlKind); if (pageUrlData == null || urlKind != UrlKind.Friendly) { pageUrl = null; return(false); } pageUrl = new PageUrl(pageUrlData.PublicationScope, pageUrlData.LocalizationScope, pageUrlData.PageId, PageUrlType.Friendly); return(true); }
public FlowToken Execute(EntityToken entityToken, ActionToken actionToken, FlowControllerServicesContainer flowControllerServicesContainer) { var id = String.Empty; var title = String.Empty; var internalUrl = String.Empty; var publicUrl = String.Empty; var currentConsoleId = flowControllerServicesContainer.GetService <IManagementConsoleMessageService>().CurrentConsoleId; var mediaToken = actionToken as GetMediaLinkActionToken; if (mediaToken != null) { var file = mediaToken.File; id = file.Id.ToString(); title = file.FileName; internalUrl = MediaUrlHelper.GetUrl(file); publicUrl = MediaUrlHelper.GetUrl(file, false); } var pageToken = actionToken as GetPageLinkActionToken; if (pageToken != null) { var page = pageToken.Page; using (var data = new DataConnection(PublicationScope.Published)) { var publishedPage = data.Get <IPage>().SingleOrDefault(p => p.Id == page.Id); if (publishedPage != null) { page = publishedPage; } id = page.Id.ToString(); title = page.Title; internalUrl = PageUrls.BuildUrl(page, UrlKind.Internal); publicUrl = PageUrls.BuildUrl(page); } } ConsoleMessageQueueFacade.Enqueue(new MessageBoxMessageQueueItem { Title = title, Message = "Id: " + id + "\n\rInternal: " + internalUrl + "\n\rPublic url: " + publicUrl }, currentConsoleId); return(null); }
public static string GetBlogUrl(Entries blogEntry, string pageUrl = "") { if (string.IsNullOrEmpty(pageUrl)) { var page = PageManager.GetPageById(blogEntry.PageId); if (page == null) { return(null); } pageUrl = PageUrls.BuildUrl(page); } return(string.Format("{0}{1}", pageUrl, GetBlogLocalPath(blogEntry))); }
public static string GetBlogUrl(DateTime date, string title, Guid pageId, string pageUrl = "") { if (string.IsNullOrEmpty(pageUrl)) { var page = PageManager.GetPageById(pageId); if (page == null) { return(null); } pageUrl = PageUrls.BuildUrl(page); } return(string.Format("{0}{1}", pageUrl, GetBlogPath(date, title))); }
internal static PageUrl ParsePublicUrl(UrlBuilder urlBuilder, out NameValueCollection notUsedQueryParameters) { UrlKind urlKind; PageUrlData pageUrlData = PageUrls.ParseUrl(urlBuilder.ToString(), out urlKind); if (pageUrlData == null || urlKind != UrlKind.Public) { notUsedQueryParameters = null; return(null); } notUsedQueryParameters = pageUrlData.QueryParameters; return(new PageUrl(pageUrlData.PublicationScope, pageUrlData.LocalizationScope, pageUrlData.PageId, PageUrlType.Public)); }
public virtual string GetPageUrl(Guid pageId, CultureInfo cultureInfo = null, HttpContext httpContext = null) { if (pageId == Guid.Empty) { throw new ArgumentException(GetMessageOfEmpty(), nameof(pageId)); } var page = GetPage(pageId, cultureInfo); return(page == null ? null : httpContext != null ? PageUrls.BuildUrl(page, UrlKind.Public, new UrlSpace(httpContext)) : PageUrls.BuildUrl(page)); }
/// <summary> /// Builds a url of the the specified URL type. /// </summary> /// <param name="urlType">Type of the URL.</param> /// <returns></returns> public UrlBuilder Build(PageUrlType urlType) { IPage page = GetPage(); if (page == null) { return(null); } PageUrlData pageUrlData = new PageUrlData(page); string url = PageUrls.BuildUrl(pageUrlData, ToUrlKind(urlType), new UrlSpace()); return(url != null ? new UrlBuilder(url) : null); }
private static string GetPagePreviewUrl(PageUrlData pageUrlData) { var httpContext = HttpContext.Current; var urlSpace = new UrlSpace(); if (HostnameBindingsFacade.GetBindingForCurrentRequest() != null || HostnameBindingsFacade.GetAliasBinding(httpContext) != null) { urlSpace.ForceRelativeUrls = true; } return(PageUrls.BuildUrl(pageUrlData, UrlKind.Public, urlSpace) ?? PageUrls.BuildUrl(pageUrlData, UrlKind.Renderer, urlSpace)); }
/// <exclude /> public static void RenderPageIfNotRendered(IPage page) { if (IsPageRendered(page) || PageRenderer.CurrentPageId == page.Id) { return; } bool lockTaken = false; try { Monitor.TryEnter(_pageRenderingLock, PageRenderingQueueWaitingTimeout, ref lockTaken); if (IsPageRendered(page)) { return; } try { RenderPage(page); } catch (Exception ex) { string pageUrl = PageUrls.BuildUrl(page) ?? "(no url)"; Log.LogError(LogTitle, "Failed to render page '{0}', Id: {1}", pageUrl, page.Id); Log.LogError(LogTitle, ex); } } finally { if (lockTaken) { Monitor.Exit(_pageRenderingLock); } if (!lockTaken) { if (!IsPageRendered(page)) { Log.LogWarning("DataUrls", "Timeout on page rendering waiting queue"); } } MarkPageAsRendered(page); } }
void CrawlExternalUrls(PageUrls page) { if (page.ExternalUrls != null) { foreach (var url in page.ExternalUrls) { if (cancelTicket) { return; } if (!urlsForCheck.ContainsKey(url.Url)) { CrawlOneUrlProducer(url.Url); } } } }
/// <exclude /> public override SiteMapNode FindSiteMapNode(string rawUrl) { var pageUrl = PageUrls.ParseUrl(rawUrl); if (pageUrl == null || !string.IsNullOrEmpty(pageUrl.PathInfo)) { return(null); } var page = pageUrl.GetPage(); if (page == null) { return(null); } return(new CmsPageSiteMapNode(this, page)); }
/// <exclude /> public SiteMapNode FindSiteMapNode(SiteMapProvider provider, string rawUrl) { var pageUrl = PageUrls.ParseUrl(rawUrl); if (pageUrl == null || !String.IsNullOrEmpty(pageUrl.PathInfo)) { return(null); } var page = pageUrl.GetPage(); if (page == null) { return(null); } return(new CmsPageSiteMapNode(provider, page)); }
public Navigation(IE browser) { _browser = browser; _pageUrls = new PageUrls(); }