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();
}
