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