public IEnumerable <Element> GetChildren(EntityToken entityToken, SearchToken searchToken) { if (entityToken is SharedCodeFolderEntityToken) { return(GetSharedCodeElements(searchToken)); } if ((entityToken is PageTemplateRootEntityToken) == false) { return new Element[] { } } ; bool sharedFilesExist = PageTemplateFacade.GetSharedFiles().Any(); IEnumerable <Element> result = sharedFilesExist ? new [] { GetSharedCodeElement() } : new Element[0]; var pageTemplates = PageTemplateFacade.GetPageTemplates(); if (searchToken.IsValidKeyword()) { string keyword = searchToken.Keyword.ToLowerInvariant(); pageTemplates = pageTemplates .Where(t => t.Title.IndexOf(keyword, StringComparison.InvariantCultureIgnoreCase) > 0); } pageTemplates = pageTemplates.OrderBy(template => template.Title).ToList(); return(result.Concat(GetElements(pageTemplates))); }
private void ParseExistingTemplateForCopying(Guid templateId, out string codeTemplate, out string folderPath) { var razorTemplate = PageTemplateFacade.GetPageTemplate(templateId) as RazorPageTemplateDescriptor; Verify.IsNotNull(razorTemplate, "Failed to get razor template descriptor by id '{0}'", templateId); var provider = PageTemplateProviderRegistry.GetProviderByTemplateId(templateId) as RazorPageTemplateProvider; Verify.IsNotNull(provider, "Failed to get razor template provider by template id '{0}'", templateId); string fullPath = PathUtil.Resolve(razorTemplate.VirtualPath); string text = C1File.ReadAllText(fullPath); const string quote = @""""; Verify.That(text.IndexOf(templateId.ToString(), StringComparison.OrdinalIgnoreCase) > 0, "Failed to replace existing templateId '{0}'", templateId); text = text.Replace(templateId.ToString(), Marker_TemplateId, StringComparison.OrdinalIgnoreCase); // Replacing title text = text.Replace("@" + quote + razorTemplate.Title.Replace(quote, quote + quote) + quote, quote + Marker_TemplateTitle + quote) .Replace(quote + CSharpEncodeString(razorTemplate.Title) + quote, quote + Marker_TemplateTitle + quote); codeTemplate = text; folderPath = Path.GetDirectoryName(fullPath); }
private void IsTitleUsed(object sender, ConditionalEventArgs e) { string title = this.GetBinding <string>(Binding_Title); e.Result = PageTemplateFacade.GetPageTemplates() .Any(f => f.Title.Equals(title, StringComparison.InvariantCultureIgnoreCase)); }
private void initializeCodeActivity_ExecuteCode(object sender, EventArgs e) { DataEntityToken token = (DataEntityToken)this.EntityToken; IVisualFunction function = (IVisualFunction)token.Data; this.Bindings.Add("OriginalFullName", string.Format("{0}.{1}", function.Namespace, function.Name)); this.Bindings.Add("Function", function); this.Bindings.Add("XhtmlBody", function.XhtmlTemplate); Type interfaceType = TypeManager.GetType(function.TypeManagerName); DataTypeDescriptor typeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(interfaceType); this.Bindings.Add("EmbedableFieldsTypes", new List <Type> { interfaceType }); this.Bindings.Add("SourceTypeFullName", interfaceType.FullName); this.Bindings.Add("FieldNameList", FieldNames(typeDescriptor).ToList()); Dictionary <Guid, string> templateInfos = new Dictionary <Guid, string>(); foreach (PageTemplateDescriptor pageTemplate in PageTemplateFacade.GetPageTemplates()) { if (pageTemplate.PlaceholderDescriptions.Any()) { templateInfos.Add(pageTemplate.Id, pageTemplate.Title); } } this.Bindings.Add("PreviewTemplateId", templateInfos.First().Key); this.Bindings.Add("TemplateList", templateInfos); }
private void codeActivity1_ExecuteCode(object sender, EventArgs e) { var templateTypes = new List <Tuple <string, string, int> >(); foreach (var providerInfo in PageTemplateFacade.GetProviders()) { var provider = providerInfo.Value; if (provider.AddNewTemplateWorkflow == null) { continue; } templateTypes.Add(new Tuple <string, string, int>( providerInfo.Key, !provider.AddNewTemplateLabel.IsNullOrEmpty() ? StringResourceSystemFacade.ParseString(provider.AddNewTemplateLabel) : providerInfo.Key, provider.GetPageTemplates().Count())); } Verify.That(templateTypes.Any(), "No page templates supporting adding new templates defined in configuration"); // Most used page template type will be first in the list and preselected string preseceltedTemplate = templateTypes.OrderByDescending(t => t.Item3).Select(t => t.Item1).First(); List <KeyValuePair <string, string> > options = templateTypes .OrderBy(t => t.Item2) // Sorting alphabetically by label .Select(t => new KeyValuePair <string, string>(t.Item1, t.Item2)).ToList(); this.Bindings.Add(Binding_TemplateTypeOptions, options); this.Bindings.Add(Binding_TemplateTypeId, preseceltedTemplate); }
private void IsTitleUsed(object sender, ConditionalEventArgs e) { IXmlPageTemplate newPageTemplate = this.GetBinding <IXmlPageTemplate>("NewPageTemplate"); e.Result = PageTemplateFacade.GetPageTemplates() .Any(f => f.Title.Equals(newPageTemplate.Title, StringComparison.InvariantCultureIgnoreCase)); }
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); } }
private ITemplateDeleter GetPageTemplateDeleter(EntityToken entityToken) { if (entityToken is DataEntityToken) { return(new XmlPageTemplateDeleter(entityToken as DataEntityToken)); } if (entityToken is PageTemplateEntityToken) { Guid pageTemplateId = (entityToken as PageTemplateEntityToken).TemplateId; var pageTemplateDescriptor = PageTemplateFacade.GetPageTemplate(pageTemplateId); if (pageTemplateDescriptor is RazorPageTemplateDescriptor) { return(new RazorPageTemplateDeleter(pageTemplateDescriptor as RazorPageTemplateDescriptor)); } if (pageTemplateDescriptor is MasterPagePageTemplateDescriptor) { return(new MasterPagePageTemplateDeleter(pageTemplateDescriptor as MasterPagePageTemplateDescriptor)); } throw new NotSupportedException("Not supported page template descriptor type '{0}'" .FormatWith(pageTemplateDescriptor.GetType().FullName)); } throw new NotSupportedException("Not supported entity token type '{0}'".FormatWith(entityToken.GetType().FullName)); }
private IEnumerable <Element> GetSharedCodeElements(SearchToken searchToken) { var result = new List <Element>(); foreach (SharedFile sharedFile in PageTemplateFacade.GetSharedFiles()) { string relativeFilePath = sharedFile.RelativeFilePath; string fullPath = relativeFilePath.StartsWith("~") ? PathUtil.Resolve(relativeFilePath) : relativeFilePath; var websiteFile = new WebsiteFile(fullPath); Element element = new Element(_context.CreateElementHandle(new SharedCodeFileEntityToken(relativeFilePath))) { VisualData = new ElementVisualizedData() { Label = websiteFile.FileName, ToolTip = websiteFile.FileName, HasChildren = false, Icon = FileElementProvider.WebsiteFileIcon(websiteFile.MimeType), OpenedIcon = FileElementProvider.WebsiteFileIcon(websiteFile.MimeType) } }; element.PropertyBag.Add("Uri", PathUtil.GetWebsitePath(websiteFile.FullPath)); element.PropertyBag.Add("ElementType", websiteFile.MimeType); // Adding "Edit" action for text-editable files if (sharedFile.DefaultEditAction && MimeTypeInfo.IsTextFile(websiteFile.MimeType)) { element.AddWorkflowAction( "Composite.Plugins.Elements.ElementProviders.PageTemplateElementProvider.EditSharedCodeFileWorkflow", new[] { PermissionType.Edit }, new ActionVisualizedData { Label = GetResourceString("EditSharedCodeFile.Label"), ToolTip = GetResourceString("EditSharedCodeFile.ToolTip"), Icon = CommonCommandIcons.Edit, Disabled = websiteFile.IsReadOnly, ActionLocation = new ActionLocation { ActionType = ActionType.Edit, IsInFolder = false, IsInToolbar = true, ActionGroup = EditCodeFileActionGroup } }); } var customActions = sharedFile.GetActions(); foreach (var action in customActions) { element.AddAction(action); } result.Add(element); } return(result); }
private RazorPageTemplateDescriptor GetPageTemplateDescriptor() { Guid templateId = GetTemplateId(); var template = PageTemplateFacade.GetPageTemplates().FirstOrDefault(t => t.Id == templateId); Verify.IsNotNull(template, "Faile to find page template by ID '{0}'", templateId); return((PageTemplates.Razor.RazorPageTemplateDescriptor)template); }
private void codeActivity2_ExecuteCode(object sender, EventArgs e) { string providerName = this.GetBinding <string>(Binding_TemplateTypeId); Type workflowType = PageTemplateFacade.GetProviders() .First(p => p.Key == providerName) .Value.AddNewTemplateWorkflow; this.ExecuteAction(new PageTemplateRootEntityToken(), new WorkflowActionToken(workflowType)); }
private void SetUpTextAreas(bool flush) { Guid selectedTemplateId = this.SelectedTemplateId; PageTemplateDescriptor pageTemplate = PageTemplateFacade.GetPageTemplate(selectedTemplateId); Verify.IsNotNull(pageTemplate, "Failed to get page template by id '{0}'", selectedTemplateId); if (!pageTemplate.IsValid) { throw new InvalidOperationException( "Page template '{0}' contains errors. You can edit the template in the 'Layout' section".FormatWith(selectedTemplateId), pageTemplate.LoadingException); } var handledIds = new List <string>(); ContentsPlaceHolder.Controls.Clear(); foreach (var placeholderDescription in pageTemplate.PlaceholderDescriptions) { string placeholderId = placeholderDescription.Id; if (handledIds.Contains(placeholderId) == false) { var pageTypeContainerClasses = ContainerClassManager.GetPageTypeContainerClasses(this.PageTypeId, placeholderDescription.Id); var allContainerClasses = ContainerClassManager.MergeContainerClasses(placeholderDescription.ContainerClasses, pageTypeContainerClasses); TextBox contentTextBox = new Composite.Core.WebClient.UiControlLib.TextBox(); contentTextBox.TextMode = TextBoxMode.MultiLine; contentTextBox.ID = placeholderId; contentTextBox.Attributes.Add("placeholderid", placeholderId); contentTextBox.Attributes.Add("placeholdername", placeholderDescription.Title); contentTextBox.Attributes.Add("containerclasses", string.Join(",", allContainerClasses)); if (placeholderId == pageTemplate.DefaultPlaceholderId) { contentTextBox.Attributes.Add("selected", "true"); } if (flush) { if (this.NamedXhtmlFragments.ContainsKey(placeholderId)) { contentTextBox.Text = this.NamedXhtmlFragments[placeholderId]; } else { contentTextBox.Text = ""; } } ContentsPlaceHolder.Controls.Add(contentTextBox); handledIds.Add(placeholderId); } } }
private string GetFilePath() { var entityToken = (SharedCodeFileEntityToken)this.EntityToken; string relativeFilePath = entityToken.VirtualPath; // Security check that validates that the file is a Shared code file var sharedFiles = PageTemplateFacade.GetSharedFiles(); Verify.That(sharedFiles.Any(sf => string.Compare(sf.RelativeFilePath, relativeFilePath, StringComparison.OrdinalIgnoreCase) == 0), "There's no page template provider that would claim ownership over shared code file '{0}'"); return(PathUtil.Resolve(relativeFilePath)); }
private void AttachRendererToAspNetPage(HttpContext context) { Verify.IsNotNull(context.Handler, "HttpHandler isn't defined"); var aspnetPage = context.Handler as System.Web.UI.Page; if (aspnetPage == null) { return; } var pageRenderer = PageTemplateFacade.BuildPageRenderer(Page.TemplateId); pageRenderer.AttachToPage(aspnetPage, PageContentToRender); }
private static Guid?ResolveTemplate(string template) { var templates = PageTemplateFacade.GetPageTemplates().OfType <MvcPageTemplateDescriptor>().ToList(); Guid templateId; if (Guid.TryParse(template, out templateId) && templates.Any(t => t.Id == templateId)) { return(templateId); } var c1Template = templates.FirstOrDefault(t => t.Title == template); return(c1Template == null ? (Guid?)null : c1Template.Id); }
private bool AnyTemplatesContainingPlaceholderId() { IPageTypeDefaultPageContent defaultPageContent = this.GetBinding <IPageTypeDefaultPageContent>("DefaultPageContent"); foreach (var templateDescriptor in PageTemplateFacade.GetPageTemplates()) { if (templateDescriptor.PlaceholderDescriptions .Any(placholder => placholder.Id == defaultPageContent.PlaceHolderId)) { return(true); } } return(false); }
private void editPreviewCodeActivity_ExecuteCode(object sender, EventArgs e) { try { XhtmlDocument templateDocument = GetTemplateDocumentFromBindings(); IVisualFunction function = this.GetBinding <IVisualFunction>("Function"); Type interfaceType = TypeManager.GetType(function.TypeManagerName); DataTypeDescriptor typeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(interfaceType); this.LogMessage(Composite.Core.Logging.LogLevel.Info, DataScopeManager.CurrentDataScope.Name); FunctionContextContainer fcc = PageRenderer.GetPageRenderFunctionContextContainer(); XhtmlDocument result = RenderingHelper.RenderCompleteDataList(function, templateDocument, typeDescriptor, fcc); IPage previewPage = DataFacade.BuildNew <IPage>(); previewPage.Id = GetRootPageId(); previewPage.Title = function.Name; previewPage.DataSourceId.DataScopeIdentifier = DataScopeIdentifier.Administrated; previewPage.DataSourceId.LocaleScope = LocalizationScopeManager.CurrentLocalizationScope; previewPage.TemplateId = this.GetBinding <Guid>("PreviewTemplateId"); var pageTemplate = PageTemplateFacade.GetPageTemplate(previewPage.TemplateId); IPagePlaceholderContent placeHolderContent = DataFacade.BuildNew <IPagePlaceholderContent>(); placeHolderContent.Content = string.Concat((result.Body.Elements().Select(b => b.ToString())).ToArray()); placeHolderContent.PlaceHolderId = pageTemplate.DefaultPlaceholderId; string output = PagePreviewBuilder.RenderPreview(previewPage, new List <IPagePlaceholderContent> { placeHolderContent }); var serviceContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId); var webRenderService = serviceContainer.GetService <IFormFlowWebRenderingService>(); webRenderService.SetNewPageOutput(new LiteralControl(output)); } catch (Exception ex) { FlowControllerServicesContainer serviceContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId); Control errOutput = new LiteralControl("<pre>" + ex + "</pre>"); var webRenderService = serviceContainer.GetService <IFormFlowWebRenderingService>(); webRenderService.SetNewPageOutput(errOutput); } }
public IEnumerable <Element> GetRoots(SearchToken searchToken) { Element element = new Element(_context.CreateElementHandle(new PageTemplateRootEntityToken())); bool hasChildren = PageTemplateFacade.GetPageTemplates().Any(); element.VisualData = new ElementVisualizedData { Label = SR.GetString("Composite.Plugins.PageTemplateElementProvider", "PageTemplateElementProvider.RootLabel"), ToolTip = SR.GetString("Composite.Plugins.PageTemplateElementProvider", "PageTemplateElementProvider.RootLabelToolTip"), HasChildren = hasChildren, Icon = PageTemplateElementProvider.RootClosed, OpenedIcon = PageTemplateElementProvider.RootOpen }; const string addTemplateWorkflowType = "Composite.Plugins.Elements.ElementProviders.PageTemplateElementProvider.AddNewPageTemplateWorkflow"; element.AddWorkflowAction(addTemplateWorkflowType, new[] { PermissionType.Add }, new ActionVisualizedData { Label = SR.GetString("Composite.Plugins.PageTemplateElementProvider", "PageTemplateElementProvider.AddTemplate"), ToolTip = SR.GetString("Composite.Plugins.PageTemplateElementProvider", "PageTemplateElementProvider.AddTemplateToolTip"), Icon = PageTemplateElementProvider.AddTemplate, Disabled = false, ActionLocation = new ActionLocation { ActionType = ActionType.Add, IsInFolder = false, IsInToolbar = true, ActionGroup = PrimaryActionGroup } }); foreach (var pageTemplateProviderName in PageTemplateProviderRegistry.ProviderNames) { var provider = PageTemplateProviderPluginFacade.GetProvider(pageTemplateProviderName); Verify.IsNotNull(provider, "Failed to get provider by name '{0}'", pageTemplateProviderName); IEnumerable <ElementAction> actions = provider.GetRootActions(); element.AddAction(actions); } return(new [] { element }); }
private void codeActivity1_ExecuteCode(object sender, EventArgs e) { this.Bindings.Add(Binding_Title, string.Empty); List <KeyValuePair <Guid, string> > templatesOptions = (from template in PageTemplateFacade.GetPageTemplates().OfType <RazorPageTemplateDescriptor>() where template.IsValid orderby template.Title select new KeyValuePair <Guid, string>(template.Id, template.Title)).ToList(); templatesOptions.Insert(0, new KeyValuePair <Guid, string>( Guid.Empty, GetText("AddNewRazorPageTemplate.LabelCopyFromEmptyOption"))); Guid mostUsedTemplate = PageTemplateHelper.GetTheMostUsedTemplate(templatesOptions.Select(p => p.Key)); this.Bindings.Add("CopyOfOptions", templatesOptions); this.Bindings.Add("CopyOfId", mostUsedTemplate); }
private List <KeyValuePair <Guid, string> > GetSelectablePageTemplates() { var selectedPage = GetBinding <IPage>("SelectedPage"); var allPageTemplates = PageTemplateFacade.GetPageTemplates().ToList(); var templateRestrictions = DataFacade.GetData <IPageTypePageTemplateRestriction>() .Where(f => f.PageTypeId == selectedPage.PageTypeId) .Select(restriction => restriction.PageTemplateId) .ToList(); IEnumerable <PageTemplateDescriptor> result; if (templateRestrictions.Any()) { var allowedTemplatesHash = new HashSet <Guid>(templateRestrictions); var allowedTemplates = allPageTemplates .Where(template => allowedTemplatesHash.Contains(template.Id)) .ToList(); var selectedTemplateId = selectedPage.TemplateId; var selectedTemplate = allPageTemplates.FirstOrDefault(t => t.Id == selectedTemplateId); if (selectedTemplate != null & !allowedTemplates.Any(t => t.Id == selectedTemplateId)) { allowedTemplates.Add(selectedTemplate); } result = allowedTemplates; } else { result = allPageTemplates; } return(result .OrderBy(template => template.Title) .Select(f => new KeyValuePair <Guid, string>(f.Id, f.Title)).ToList()); }
protected override void OnActionExecuting(ActionExecutingContext filterContext) { var pageUrlData = PageUrls.ParseUrl(HttpContext.Request.Path); if (pageUrlData == null) { return; } C1PageRoute.PageUrlData = pageUrlData; _mvcContext = new MvcRenderingContext(ControllerContext); var page = PageRenderer.CurrentPage; ViewData.Add("C1PreviewContent", HttpContext.Items["C1PreviewContent"]); _template = PageTemplateFacade.GetPageTemplate(page.TemplateId) as MvcPageTemplateDescriptor; if (_template == null) { throw new InvalidOperationException(String.Format("The pagetemplate '{0}' is not a valid mvc template", page.TemplateId)); } var templateModel = Activator.CreateInstance(_template.TypeInfo.Item1); if (_template.PlaceholderDescriptions != null && _template.PlaceholderDescriptions.Any()) { foreach (var placeholder in _template.PlaceholderDescriptions) { var name = placeholder.Id; var prop = _template.TypeInfo.Item2[name]; var content = GetPlaceholderContent(name); BindPlaceholder(templateModel, prop, content); } } ViewData.Add("TemplateModel", templateModel); base.OnActionExecuting(filterContext); }
private void ParseTemplateForCopying( Guid templateId, out string markupTemplate, out string codebehindTemplate, out string templateFolder) { var masterTemplate = PageTemplateFacade.GetPageTemplate(templateId) as MasterPagePageTemplateDescriptor; Verify.IsNotNull(masterTemplate, "Failed to get MasterPagePageTemplateDescriptor by template id '{0}'", templateId); var provider = PageTemplateProviderRegistry.GetProviderByTemplateId(templateId) as MasterPagePageTemplateProvider; Verify.IsNotNull(provider, "Failed to get MasterPagePageTemplateProvider by template id '{0}'", templateId); string markup = C1File.ReadAllText(masterTemplate.FilePath); string codebehind = C1File.ReadAllText(masterTemplate.CodeBehindFilePath); string codebehindFileName = Path.GetFileName(masterTemplate.CodeBehindFilePath); // Parsing markup markup = markup.Replace(codebehindFileName, Marker_Codebehind); // Parsing codebehind const string quote = @""""; Verify.That(codebehind.IndexOf(templateId.ToString(), StringComparison.OrdinalIgnoreCase) > 0, "Failed to replace existing templateId '{0}'", templateId); codebehind = codebehind.Replace(templateId.ToString(), Marker_TemplateId, StringComparison.OrdinalIgnoreCase); // Replacing title, considering 2 types of encoding codebehind = codebehind.Replace("@" + quote + masterTemplate.Title.Replace(quote, quote + quote) + quote, quote + Marker_TemplateTitle + quote); codebehind = codebehind.Replace(quote + CSharpEncodeString(masterTemplate.Title) + quote, quote + Marker_TemplateTitle + quote); markupTemplate = markup; codebehindTemplate = codebehind; templateFolder = Path.GetDirectoryName(masterTemplate.CodeBehindFilePath); }
static TeaserElementAttachingProvider() { TemplateTeaserPositions = new Dictionary <Guid, IList <Tuple <string, string> > >(); var config = TeasersSection.GetSection(); var positions = config.Positions.Cast <TeasersPositionElement>().ToDictionary(e => e.Name, e => e.Label); var templates = PageTemplateFacade.GetPageTemplates(); foreach (var template in templates) { var templatePositions = config.Templates.Cast <TeasersTemplateElement>().SingleOrDefault(e => e.Guid == template.Id); if (templatePositions == null) { continue; } var tupleList = templatePositions.Positions.Cast <TeasersTemplatePositionElement>().Select(e => Tuple.Create(e.Name, positions[e.Name])).ToList(); TemplateTeaserPositions.Add(template.Id, tupleList); } }
// private static readonly string HtmlMimeType = "text/html"; private string[] GetFiles() { var entityToken = this.EntityToken; if (entityToken is PageTemplateEntityToken) { var masterTemplate = GetPageTemplate(); return(masterTemplate.GetFiles()); } if (entityToken is SharedCodeFileEntityToken) { var sharedFileEntityToken = (SharedCodeFileEntityToken)this.EntityToken; string relativeFilePath = sharedFileEntityToken.VirtualPath; // Security check that validates that the file is a Shared code file var sharedFiles = PageTemplateFacade.GetSharedFiles(); Verify.That(sharedFiles.Any(sharedFile => string.Compare(sharedFile.RelativeFilePath, relativeFilePath, StringComparison.OrdinalIgnoreCase) == 0), "There's no page template provider that would claim ownership over shared code file '{0}'"); string fullPath = PathUtil.Resolve(relativeFilePath); string codebehindFile = MasterPagePageTemplateProvider.GetCodebehindFilePath(fullPath); var result = new List <string>(); result.Add(fullPath); if (codebehindFile != null) { result.Add(codebehindFile); } return(result.ToArray()); } throw new InvalidOperationException("Invalid entity token type '{0}'".FormatWith(entityToken.GetType().Name)); }
static void app_PostMapRequestHandler(object sender, EventArgs e) { var ctx = ((HttpApplication)sender).Context; var handler = ctx.CurrentHandler as Page; if (handler == null) { return; } handler.Load += (o, args) => { var c1Page = PageRenderer.CurrentPage; if (c1Page != null) { var template = PageTemplateFacade.GetPageTemplate(c1Page.TemplateId); var title = template.Title; NewRelicAgent.SetTransactionName("C1 Page", title); } else { var adminPath = UrlUtils.AdminRootPath; var requestPath = ctx.Request.Url.LocalPath; if (!requestPath.StartsWith(adminPath, StringComparison.OrdinalIgnoreCase)) { return; } var newRelic = handler.Request.QueryString["newrelic"]; if (newRelic == null || !newRelic.Equals("true")) { NewRelicAgent.DisableBrowserMonitoring(true); } } }; }
public void Pack(PackageCreator creator) { var pageTemplate = PageTemplateFacade.GetPageTemplates().FirstOrDefault(t => t.Title == Id); if (pageTemplate == null) { throw new InvalidOperationException(string.Format("Template '{0}' does not exists", Id)); } if (pageTemplate.GetType().Name.Contains("MasterPagePageTemplateDescriptor")) { var codeBehindFilePath = pageTemplate.GetProperty("CodeBehindFilePath"); var filePath = pageTemplate.GetProperty("FilePath"); creator.AddFile("~" + PathUtil.GetWebsitePath(codeBehindFilePath)); creator.AddFile("~" + PathUtil.GetWebsitePath(filePath)); } else if (pageTemplate.GetType().Name.Contains("RazorPageTemplateDescriptor")) { var virtualPath = pageTemplate.GetProperty("VirtualPath"); creator.AddFile(virtualPath); } }
private void codeActivity1_ExecuteCode(object sender, EventArgs e) { IXmlPageTemplate newPageTemplate = DataFacade.BuildNew <IXmlPageTemplate>(); newPageTemplate.Id = Guid.NewGuid(); newPageTemplate.Title = ""; this.Bindings.Add("NewPageTemplate", newPageTemplate); List <KeyValuePair <Guid, string> > templatesOptions = (from template in PageTemplateFacade.GetPageTemplates() where template is XmlPageTemplateDescriptor && template.IsValid orderby template.Title select new KeyValuePair <Guid, string>(template.Id, template.Title)).ToList(); templatesOptions.Insert(0, new KeyValuePair <Guid, string>( Guid.Empty, GetText("AddNewXmlPageTemplate.LabelCopyFromEmptyOption"))); Guid mostUsedTemplate = PageTemplateHelper.GetTheMostUsedTemplate(templatesOptions.Select(p => p.Key)); this.Bindings.Add("CopyOfOptions", templatesOptions); this.Bindings.Add("CopyOfId", mostUsedTemplate); }
public override RouteData GetRouteData(HttpContextBase httpContext) { var path = httpContext.Request.Path; var pageUrlData = PageUrls.ParseUrl(path); if (pageUrlData == null) { return(null); } using (new DataScope(pageUrlData.PublicationScope, pageUrlData.LocalizationScope)) { var page = PageManager.GetPageById(pageUrlData.PageId); var templateIds = PageTemplateFacade.GetPageTemplates().OfType <MvcPageTemplateDescriptor>().Select(t => t.Id); if (!templateIds.Contains(page.TemplateId)) { return(null); } var template = PageTemplateFacade.GetPageTemplate(page.TemplateId) as MvcPageTemplateDescriptor; if (template == null) { return(null); } } return(new RouteData(this, new MvcRouteHandler()) { Values = { { "controller", _controller.ControllerName }, { "action", "Get" } } }); }
private void initializeCodeActivity_UpdateBindings_ExecuteCode(object sender, EventArgs e) { IPageType pageType = (IPageType)((DataEntityToken)this.EntityToken).Data; CleanDeadLinks(pageType.Id); this.Bindings.Add("PageType", pageType); List <KeyValuePair <Guid, string> > pageTypes = DataFacade.GetData <IPageType>(). OrderBy(f => f.Name). ToList(f => new KeyValuePair <Guid, string>(f.Id, f.Name)); var defaultPageTypeOptions = new List <KeyValuePair <Guid, string> > { new KeyValuePair <Guid, string>(Guid.Empty, Texts.PageType_EditPageTypeWorkflow_DefaultChildPageTypeKeySelector_NoneSelectedLabel) }; defaultPageTypeOptions.AddRange(pageTypes); this.Bindings.Add("DefaultChildPageTypeOptions", defaultPageTypeOptions); Func <PageTypeHomepageRelation, KeyValuePair <string, string> > getOption = relation => new KeyValuePair <string, string>( relation.ToString(), GetText($"PageType.EditPageTypeWorkflow.HomepageRelationKeySelector.{relation}Label")); this.Bindings.Add("HomepageRelationOptions", new List <KeyValuePair <string, string> > { getOption(PageTypeHomepageRelation.NoRestriction), getOption(PageTypeHomepageRelation.OnlyHomePages), getOption(PageTypeHomepageRelation.OnlySubPages), }); List <KeyValuePair <Guid, string> > pageTemplates = PageTemplateFacade.GetPageTemplates(). OrderBy(f => f.Title). ToList(f => new KeyValuePair <Guid, string>(f.Id, f.Title)); var defaultPageTemplateOptions = new List <KeyValuePair <Guid, string> > { new KeyValuePair <Guid, string>(Guid.Empty, Texts.PageType_EditPageTypeWorkflow_DefaultPageTemplateKeySelector_NoneSelectedLabel) }; defaultPageTemplateOptions.AddRange(pageTemplates); this.Bindings.Add("DefaultTemplateOptions", defaultPageTemplateOptions); this.Bindings.Add("TemplateRestrictionOptions", pageTemplates); List <Guid> selectedPageTemplateIds = DataFacade.GetData <IPageTypePageTemplateRestriction>(). Where(f => f.PageTypeId == pageType.Id). Select(f => f.PageTemplateId). ToList(); this.Bindings.Add("TemplateRestrictionSelected", selectedPageTemplateIds); List <KeyValuePair <Guid, string> > parentRestrictingPageTypes = DataFacade.GetData <IPageType>(). OrderBy(f => f.Name). ToList(f => new KeyValuePair <Guid, string>(f.Id, f.Name)); this.Bindings.Add("PageTypeChildRestrictionOptions", parentRestrictingPageTypes); List <Guid> selectedPageTypeParentRestrictions = DataFacade.GetData <IPageTypeParentRestriction>(). Where(f => f.PageTypeId == pageType.Id). Select(f => f.AllowedParentPageTypeId). ToList(); this.Bindings.Add("PageTypeChildRestrictionSelected", selectedPageTypeParentRestrictions); List <KeyValuePair <Guid, string> > dataFolderTypes = PageFolderFacade.GetAllFolderTypes(). OrderBy(f => f.FullName). ToList(f => new KeyValuePair <Guid, string>(f.GetImmutableTypeId(), f.GetTypeTitle())); this.Bindings.Add("DataFolderOptions", dataFolderTypes); List <Guid> selectedDataFolderTypes = DataFacade.GetData <IPageTypeDataFolderTypeLink>(). Where(f => f.PageTypeId == pageType.Id). Select(f => f.DataTypeId). ToList(); this.Bindings.Add("DataFolderSelected", selectedDataFolderTypes); List <KeyValuePair <string, string> > applications = TreeFacade.AllTrees. Where(f => !string.IsNullOrEmpty(f.AllowedAttachmentApplicationName)). OrderBy(f => f.TreeId). ToList(f => new KeyValuePair <string, string>(f.TreeId, f.AllowedAttachmentApplicationName)); this.Bindings.Add("ApplicationOptions", applications); List <string> selectedApplications = DataFacade.GetData <IPageTypeTreeLink>(). Where(f => f.PageTypeId == pageType.Id). Select(f => f.TreeId). ToList(); this.Bindings.Add("ApplicationSelected", selectedApplications); }
private bool IsSlimPageRenderer(Guid pageTemplate) { return(_pageRendererTypCache.GetOrAdd(pageTemplate, templateId => PageTemplateFacade.BuildPageRenderer(templateId) is ISlimPageRenderer)); }