public SerializableNode(IPublishedContent content, bool traverseChildren, bool getTemplateAlias = true) { if (traverseChildren) this.Children = content.Children.Select(c => new SerializableNode(c, traverseChildren)); else this.Children = new List<SerializableNode>(); //this.ContentType = content.ContentType; //this.ContentSet = new List<PortableNode>();// content.ContentSet; this.CreateDate = content.CreateDate; this.CreatorId = content.CreatorId; this.CreatorName = content.CreatorName; this.DocumentTypeAlias = content.DocumentTypeAlias; this.DocumentTypeId = content.DocumentTypeId; this.Id = content.Id; this.IsDraft = content.IsDraft; this.ItemType = content.ItemType; this.Level = content.Level; this.Name = content.Name; //this.Parent = content.Parent; this.ParentId = (content.Parent == null) ? -1 : content.Parent.Id; this.Path = content.Path; //this.Properties = content.Properties; //this.Properties = content.Properties.Select(p=>new SerializableProperty(p)).ToList<IPublishedProperty>();// new List<IPublishedProperty>(); this.PropertiesDictionary = content.Properties.ToDictionary(k => k.PropertyTypeAlias, k => k.DataValue); this.SortOrder = content.SortOrder; this.TemplateId = content.TemplateId; this.TemplateAlias = content.GetTemplateAlias(); this.UpdateDate = content.UpdateDate; this.Url = content.Url; this.UrlName = content.UrlName; this.Version = content.Version; this.WriterId = content.WriterId; this.WriterName = content.WriterName; }
/// <summary> /// Constructor specifying both the IPublishedContent and the CultureInfo /// </summary> /// <param name="content"></param> /// <param name="culture"></param> public RenderModel(IPublishedContent content, CultureInfo culture) { if (content == null) throw new ArgumentNullException("content"); if (culture == null) throw new ArgumentNullException("culture"); Content = content; CurrentCulture = culture; }
public static IEnumerable<NavigationItem> GetIntranetMainNavigation(IPublishedContent root, IPublishedContent current) { var results = new List<NavigationItem>(); //results.Add(new NavigationItem() //{ // Url = "/", // Name = "Hjemmeside", // CssClass = "" //}); results.Add(new NavigationItem() { Url = umbraco.library.NiceUrl(2120), Name = "Forside", CssClass = current.Id == 2120 ? "active" : "" }); results.AddRange(root.Children.Select(x => new NavigationItem() { Url = x.Url, Name = x.Name, CssClass = current.Id == x.Id ? "active" : "" }).ToList()); return results; }
/// <summary> /// Gets the model for the blog post page /// </summary> /// <param name="currentPage">The current page</param> /// <param name="currentMember">The current member</param> /// <returns>The page model</returns> public BlogPostViewModel GetBlogPostPageModel(IPublishedContent currentPage, IMember currentMember) { var model = GetPageModel<BlogPostViewModel>(currentPage, currentMember); model.ImageUrl = GravatarHelper.CreateGravatarUrl(model.Author.Email, 200, string.Empty, null, null, null); return model; }
public void SetUp() { _archetype = ContentHelpers.Archetype; var content = ContentHelpers.FakeContent(123, "Fake Node 1", properties: new Collection<IPublishedProperty> { new FakePublishedProperty("myArchetypeProperty", _archetype, true) }); _content = new FakeModel(content); _propertyDescriptor = TypeDescriptor.GetProperties(_content)["TextString"]; _context = new FakeDittoValueResolverContext(_content, _propertyDescriptor); var mockedPropertyService = new Mock<PropertyValueService>(); mockedPropertyService.SetupSequence( i => i.Set(It.IsAny<IPublishedContent>(), It.IsAny<CultureInfo>(), It.IsAny<PropertyInfo>(), It.IsAny<object>(), It.IsAny<object>(), It.IsAny<DittoValueResolverContext>())) .Returns(new HtmlString("<p>This is the <strong>summary</strong> text.</p>")) .Returns("Ready to Enroll?") .Returns("{}"); _sut = new ArchetypeBindingService(mockedPropertyService.Object, new DittoAliasLocator()); }
/// <summary> /// Gets images url list. /// /// Gets crops if cropname specified /// </summary> /// <param name="post"></param> /// <param name="cropName"></param> /// <returns></returns> public static IEnumerable<String> GetImagesUrl(IPublishedContent post, String cropName = "", String fieldAlias = "images") { List<string> result = new List<string>(); var umbracoHelper = new UmbracoHelper(UmbracoContext.Current); try { var pictureIDsVal = post.GetPropertyValue<String>(fieldAlias); if (!String.IsNullOrEmpty(pictureIDsVal)) { var pictureIDs = pictureIDsVal.Split(new string[] {","}, StringSplitOptions.RemoveEmptyEntries); foreach (var pictureIDstr in pictureIDs) { if (!String.IsNullOrEmpty(pictureIDstr)) { int id = Int32.Parse(pictureIDstr); var url = GetImageUrl(id, cropName); result.Add(url); } } } } catch (Exception e) { if (UmbracoContext.Current.IsDebug) { //throw e; } } return result; }
/// <summary> /// Converts an IPublishedContent instance to SimpleContent. /// </summary> /// <param name="content">The IPublishedContent instance you wish to convert.</param> /// <param name="recurseChildren">Whether to include the children in the SimpleContent instance.</param> /// <param name="recurseContentTypes">Whether to include the parent content types on each SimpleContent instance.</param> /// <param name="recurseTemplates">Whether to include the parent templates on each SimpleContent instance.</param> /// <returns>A SimpleContent representation of the specified IPublishedContent</returns> public static SimpleContent FromIPublishedContent(IPublishedContent content, bool recurseChildren = true, bool recurseContentTypes = true, bool recurseTemplates = true) { if (content == null) return null; /* * Using string, object for key/value pairs. * An object is used so that the JavaScriptSerializer will * automatically detect the type and serialize it to the * correct JavaScript type. */ var properties = content.Properties .Where(p => !String.IsNullOrWhiteSpace(p.Value.ToString())) .ToDictionary(prop => prop.Alias, prop => prop.Value); var result = new SimpleContent() { Id = content.Id, Name = content.Name, Url = content.Url, Level = content.Level, Properties = properties, ContentType = SimpleContentType.FromContentType(content.DocumentTypeId, recurseContentTypes), Template = SimpleTemplate.FromTemplate(content.TemplateId, recurseTemplates), ChildrenIds = content.Children.Select(x => x.Id).ToList() }; if (recurseChildren) { result.Children = FromIPublishedContent(content.Children, true, recurseContentTypes, recurseTemplates); } return result; }
public override void Init(IPublishedContent content) { base.Init(content); this.HideInBottomNavigation = Content.GetPropertyValue<bool>("umbracoNaviHide"); }
public static string GetPostCreatorFullName(IPublishedContent member, IPublishedContent post) { string memberFullName = null; if (member != null) { memberFullName = String.Format("{0} {1}", member.GetPropertyValue<String>("arborFirstName"), member.GetPropertyValue<String>("arborLastName")).Trim(); if (String.IsNullOrEmpty(memberFullName)) { memberFullName = String.Format("{0} {1}", member.GetPropertyValue<String>("firstName"), member.GetPropertyValue<String>("lastName")).Trim(); } if (String.IsNullOrEmpty(memberFullName)) { memberFullName = member.Name; } } if (String.IsNullOrEmpty(memberFullName) && (post != null)) { memberFullName = post.CreatorName; } if (String.IsNullOrEmpty(memberFullName)) { memberFullName = "Not Available"; } return memberFullName; }
public string GetMediaUrl(IPublishedContent node, string mediaProperty) { var linkMedia = _umbracoHelper.TypedMedia(node.GetPropertyValue<int>(mediaProperty)); if (linkMedia != null) return linkMedia.GetPropertyValue<string>(MEDIA_FILE_PROPERTY); return string.Empty; }
/// <summary> /// Initializes a new instance based on the specified <code>content</code>. /// </summary> /// <param name="content">An instance of <see cref="IPublishedContent"/> representing the selected image.</param> protected ImagePickerImage(IPublishedContent content) { Image = content; Width = content.GetPropertyValue<int>(global::Umbraco.Core.Constants.Conventions.Media.Width); Height = content.GetPropertyValue<int>(global::Umbraco.Core.Constants.Conventions.Media.Height); Url = content.Url; CropUrl = content.GetCropUrl(Width, Height, preferFocalPoint: true, imageCropMode: ImageCropMode.Crop); }
protected Frontpage(IPublishedContent content) : base(content) { IPublishedContent skills = content.Children.FirstOrDefault(x => x.DocumentTypeAlias == "Skills"); IPublishedContent portfolio = content.Children.FirstOrDefault(x => x.DocumentTypeAlias == "Portfoliolist"); IPublishedContent contact = content.Children.FirstOrDefault(x => x.DocumentTypeAlias == "Contact"); Sliders = ArcheTypeSlider.GetFromContent(content.GetPropertyValue<ArchetypeModel>("sliders")); KompetencerHeadline = skills.GetPropertyValue<string>("title"); KompetencerText = skills.GetPropertyValue<string>("content"); Kompetencer = ArchetypeSkill.GetFromContent(skills.GetPropertyValue<ArchetypeModel>("skills")); PortfolioHeadline = portfolio.GetPropertyValue<string>("title"); PortfolioItems = content .Descendants("PortfolioPage") .Where(x => !x.Hidden()) .Select(PortfolioItem.GetFromContent); KontaktHeadline = contact.GetPropertyValue<string>("title"); KontaktTeaser = contact.GetPropertyValue<string>("teaser"); KontaktForm = contact.GetPropertyValue<string>("form"); AdrHeadline = contact.GetPropertyValue<string>("adrHeadline"); AdrShortText = contact.GetPropertyValue<string>("adrShortText"); AdrCompany = contact.GetPropertyValue<string>("adrCompany"); AdrAddress = contact.GetPropertyValue<string>("adrAddress"); AdrZip = contact.GetPropertyValue<string>("adrZip"); AdrCity = contact.GetPropertyValue<string>("adrCity"); AdrMobile = contact.GetPropertyValue<string>("adrMobile"); AdrEmail = contact.GetPropertyValue<string>("adrEmail"); }
private static IEnumerable<Tuple<IPublishedContent, dynamic>> GetBranch(IPublishedContent document) { IEnumerable<IPublishedContent> children = document.GetPropertyValue<bool>("excludeChildrenFromSiteMap") ? Enumerable.Empty<IPublishedContent>() : document.Children.Where(x => !x.GetPropertyValue<bool>("excludeFromSiteMap") && x.HasProperty("excludeFromSiteMap")).ToArray(); return from child in children select Tuple.Create<IPublishedContent, dynamic>(child, GetBranch(child)); }
/// <summary> /// Gets the model for the contact page /// </summary> /// <param name="currentPage">The current page</param> /// <param name="currentMember">The current member</param> /// <returns>The page model</returns> public ContactViewModel GetContactPageModel(IPublishedContent currentPage, IMember currentMember) { var model = GetPageModel<ContactViewModel>(currentPage, currentMember); Mapper.Map(currentPage, model.Form); return model; }
public static HtmlString RenderDocTypeGridEditorItem(this HtmlHelper helper, IPublishedContent content, string viewPath = "", string actionName = "", object model = null) { if (content == null) return new HtmlString(string.Empty); var controllerName = content.DocumentTypeAlias + "Surface"; if (!string.IsNullOrWhiteSpace(viewPath)) viewPath = viewPath.TrimEnd('/') + "/"; if (string.IsNullOrWhiteSpace(actionName)) actionName = content.DocumentTypeAlias; var umbracoHelper = new UmbracoHelper(UmbracoContext.Current); if (umbracoHelper.SurfaceControllerExists(controllerName, actionName, true)) { return helper.Action(actionName, controllerName, new { dtgeModel = model ?? content, dtgeViewPath = viewPath }); } if (!string.IsNullOrWhiteSpace(viewPath)) return helper.Partial(viewPath + content.DocumentTypeAlias + ".cshtml", content); return helper.Partial(content.DocumentTypeAlias, content); }
/// <summary> /// Given the set of replacement values and a list of property aliases /// of the email fields, construct and send the required emails. /// </summary> /// <param name="emailValues">The replacement values</param> /// <param name="formAliases">The node property aliases, relevant to the current node.</param> protected void ProcessForms(Dictionary<string, string> emailValues, IPublishedContent content, EmailType emailType, params string[] formAliases) { // process each of the given property names, retrieving the form data, // replacing placeholders, and sending the email. foreach (var alias in formAliases) { var prop = content.GetPropertyValue<string>(alias, true, string.Empty); if (prop != null) { var emailFields = DEF_Helper.GetFields(prop); if (emailFields.Send) { ReplacePlaceholders(emailFields, emailValues); emailFields.Body = AddImgAbsolutePath(emailFields.Body); Umbraco.SendEmail( emailFields.SenderEmail, emailFields.SenderName, emailFields.ReceiverEmail, emailFields.Subject, emailFields.Body, emailFields.CCEmail, emailFields.BCCEmail, emailType: emailType ); } } } }
public ConvertedNode(IPublishedContent doc) { _doc = doc; if (doc == null) { Id = 0; return; } template = doc.TemplateId; Id = doc.Id; Path = doc.Path; CreatorName = doc.CreatorName; SortOrder = doc.SortOrder; UpdateDate = doc.UpdateDate; Name = doc.Name; NodeTypeAlias = doc.DocumentTypeAlias; CreateDate = doc.CreateDate; CreatorID = doc.CreatorId; Level = doc.Level; UrlName = doc.UrlName; Version = doc.Version; WriterID = doc.WriterId; WriterName = doc.WriterName; }
private static object CreateMagicModel(Type genericType, IPublishedContent content) { var contentType = content.GetType(); var modelType = genericType.MakeGenericType(contentType); var model = Activator.CreateInstance(modelType, content); return model; }
public override void Init(IPublishedContent content) { base.Init(content); this.Name = Content.GetPropertyValue<string>("name"); }
public virtual void HandleSubmission(FormModel model, IPublishedContent content) { var cookieValue = (Request.Cookies.AllKeys.Contains(FormSubmittedCookieKey) ? Request.Cookies[FormSubmittedCookieKey].Value : null) ?? string.Empty; var containsCurrentContent = cookieValue.Contains(FormSubmittedCookieValue(content)); if(model.DisallowMultipleSubmissionsPerUser == false) { if(containsCurrentContent) { // "only one submission per user" must've been enabled for this form at some point - explicitly remove the content ID from the cookie cookieValue = cookieValue.Replace(FormSubmittedCookieValue(content), ","); if(cookieValue == ",") { // this was the last content ID - remove the cookie Response.Cookies.Add(new HttpCookie(FormSubmittedCookieKey, cookieValue) { Expires = DateTime.Today.AddDays(-1) }); } else { // update the cookie value Response.Cookies.Add(new HttpCookie(FormSubmittedCookieKey, cookieValue) { Expires = DateTime.Today.AddDays(30) }); } } return; } // add the content ID to the cookie value if it's not there already if(containsCurrentContent == false) { cookieValue = string.Format("{0}{1}", cookieValue.TrimEnd(','), FormSubmittedCookieValue(content)); } Response.Cookies.Add(new HttpCookie(FormSubmittedCookieKey, cookieValue) { Expires = DateTime.Today.AddDays(30) }); }
/// <summary> /// Generates css class for current node from its doctype and name /// </summary> /// <param name="currentNode"></param> /// <returns> /// Doctypes: post, category, homepage, other-type /// </returns> public static String GenerateCSSClass(IPublishedContent currentNode) { //TODO: solve multilanguage issue (url names will differ for same pages) String result = "other-type"; if (currentNode != null) { var typeService = ApplicationContext.Current.Services.ContentTypeService; IContentType nodeType = typeService.GetContentType(currentNode.DocumentTypeAlias); if (nodeType != null) { if ( nodeType.ContentTypeCompositionExists("Category") || currentNode.DocumentTypeAlias == "Category" || currentNode.DocumentTypeAlias == "SearchResults" || currentNode.DocumentTypeAlias == "List" ) { result = "category"; } else if ( nodeType.ContentTypeCompositionExists("Homepage") || currentNode.DocumentTypeAlias == "Homepage" ) { result = "homepage"; } else if ( nodeType.ContentTypeCompositionExists("SimplePage") || currentNode.DocumentTypeAlias == "Contact" || currentNode.DocumentTypeAlias == "ListElement" || currentNode.DocumentTypeAlias == "SimplePage" || currentNode.DocumentTypeAlias == "Site_Infographic" ) { result = "post"; } } IEnumerable<IPublishedContent> ancestors = currentNode.AncestorsOrSelf(); foreach (IPublishedContent ancestor in ancestors) { if (ancestor.Level > 0) { result += " con_" + ancestor.UrlName; } } //add document type var projectPrefixes = new string[] {"Site_", "Academy_", "Creative_" }; var doctypeName = currentNode.DocumentTypeAlias; foreach (var prefix in projectPrefixes) { doctypeName = doctypeName.Replace(prefix, ""); } doctypeName = Regex.Replace(doctypeName, "(\\B[A-Z])", "-$1"); doctypeName = doctypeName.ToCharArray()[0] == '-' ? doctypeName.Substring(1) : doctypeName ; result += " doc_" + doctypeName.ToLower().Replace(" ", "-").Replace("_", ""); } return result; }
/// <summary> /// Method to get the model for the footer navigation /// </summary> /// <param name="currentPage">Current page</param> /// <returns>Navigation model</returns> public NavigationViewModel GetFooterNavigation(IPublishedContent currentPage) { return new NavigationViewModel { Items = GetMenuItems(currentPage, PropertyAliases.FooterNavigation) }; }
public override void Init(IPublishedContent content) { base.Init(content); this.Authors = Content.GetPropertyValue<string>("authors"); }
/// <summary> /// Creates a strongly-typed model representing a published content. /// </summary> /// <param name="content">The original published content.</param> /// <returns> /// The strongly-typed model representing the published content, or the published content /// itself it the factory has no model for that content type. /// </returns> public IPublishedContent CreateModel(IPublishedContent content) { // HACK: [LK:2014-12-04] It appears that when a Save & Publish is performed in the back-office, the model-factory's `CreateModel` is called. // This can cause a null-reference exception in specific cases, as the `UmbracoContext.PublishedContentRequest` might be null. // Ref: https://github.com/leekelleher/umbraco-ditto/issues/14 if (UmbracoContext.Current == null || UmbracoContext.Current.PublishedContentRequest == null) { return content; } if (this.converterCache == null) { return content; } var contentTypeAlias = content.DocumentTypeAlias; Func<IPublishedContent, IPublishedContent> converter; if (!this.converterCache.TryGetValue(contentTypeAlias, out converter)) { return content; } return converter(content); }
/// <summary> /// Builds a <see cref="ILinkTier"/> /// </summary> /// <param name="tierItem">The <see cref="IPublishedContent"/> "tier" item (the parent tier)</param> /// <param name="current">The current <see cref="IPublishedContent"/> in the recursion</param> /// <param name="excludeDocumentTypes">A collection of document type aliases to exclude</param> /// <param name="tierLevel">The starting "tier" level. Note this is the Umbraco node level</param> /// <param name="maxLevel">The max "tier" level. Note this is the Umbraco node level</param> /// <param name="includeContentWithoutTemplate">True or false indicating whether or not to include content that does not have an associated template</param> /// <returns>the <see cref="ILinkTier"/></returns> public ILinkTier BuildLinkTier(IPublishedContent tierItem, IPublishedContent current, string[] excludeDocumentTypes = null, int tierLevel = 0, int maxLevel = 0, bool includeContentWithoutTemplate = false) { var active = current.Path.Contains(tierItem.Id.ToString(CultureInfo.InvariantCulture)); if (current.Level == tierItem.Level) active = current.Id == tierItem.Id; var tier = new LinkTier() { ContentId = tierItem.Id, ContentTypeAlias = tierItem.DocumentTypeAlias, Title = tierItem.Name, Url = ContentHasTemplate(tierItem) ? tierItem.Url : string.Empty, CssClass = active ? "active" : string.Empty }; if (excludeDocumentTypes == null) excludeDocumentTypes = new string[] { }; if (tierLevel > maxLevel && maxLevel != 0) return tier; foreach (var item in tierItem.Children.ToList().Where(x => x.IsVisible() && (ContentHasTemplate(x) || (includeContentWithoutTemplate && x.IsVisible())) && !excludeDocumentTypes.Contains(x.DocumentTypeAlias))) { var newTier = BuildLinkTier(item, current, excludeDocumentTypes, item.Level, maxLevel); if (AddingTier != null) { AddingTier.Invoke(this, new AddingLinkTierEventArgs(tier, newTier)); } tier.Children.Add(newTier); } return tier; }
public static string GetImageUrl(this UmbracoContext context, IPublishedContent node, string propertyName) { var helper = new UmbracoHelper(context); var imageId = node.GetPropertyValue<int>(propertyName); var typedMedia = helper.TypedMedia(imageId); return typedMedia != null ? typedMedia.Url : null; }
/// <summary> /// Maps the image model from the media node /// </summary> /// <param name="mapper">Umbraco mapper</param> /// <param name="media">Media node</param> /// <returns>Image model</returns> public static object GetImage(IUmbracoMapper mapper, IPublishedContent media) { var image = GetModel<ImageViewModel>(mapper, media); MapImageCrops(media, image); return image; }
private void AddCountryToDataSet(ResultData resultData, IPublishedContent landkosten, string goalCurrency, String localizedYear) { var kostenland = new CountryCost(landkosten, goalCurrency); for (int i = 1; i <= 20; i++) { int jaarTakseInGoalCurrency = kostenland.GetYear(i) ?? default(int); if (jaarTakseInGoalCurrency > resultData.MaxTakse) { resultData.MaxTakse = jaarTakseInGoalCurrency; } resultData.AddDataPoint(i, jaarTakseInGoalCurrency, localizedYear); } string stepWidthString = (resultData.MaxTakse / 10).ToString(); int biggestInt = Convert.ToInt32(stepWidthString[0].ToString()) + 1; string nextBigNumberforStep = biggestInt.ToString(); for (int i = 0; i < stepWidthString.Length - 1; i++) { nextBigNumberforStep += "0"; } int nextBigNumberForStepInt = Convert.ToInt32(nextBigNumberforStep); resultData.StepWidth = nextBigNumberForStepInt; }
/// <summary> /// Gets the path to the currently assigned theme. /// </summary> /// <param name="model"> /// The <see cref="IMasterModel"/>. /// </param> /// <returns> /// The <see cref="string"/> representing the path to the starter kit theme folder. /// </returns> public static string GetThemePath(IPublishedContent model) { const string Path = "~/App_Plugins/Merchello.Bazaar/Themes/{0}/"; return model.HasProperty("theme") && model.HasValue("theme") ? string.Format(Path, model.GetPropertyValue<string>("theme")) : string.Empty; }
/// <summary> /// Initializes a new instance of the <see cref="ProductOptionWrapper"/> class. /// </summary> /// <param name="display"> /// The display. /// </param> /// <param name="_parent"> /// The parent content. /// </param> /// <param name="contentType"> /// The content Type. /// </param> public ProductOptionWrapper(ProductOptionDisplay display, IPublishedContent _parent, PublishedContentType contentType = null) { _display = display; _contentType = contentType; Initialize(_parent); }
#pragma warning restore 0109 // ctor public Image(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 public MainArtiles(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 public ContactUs(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 // ctor public SignIn(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 // ctor public Member(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 // ctor public Home(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 // ctor public File(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 // ctor public Cards(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 // ctor public Titel(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 // ctor public Folder(IPublishedContent content) : base(content) { }
/// <inheritdoc /> public bool TryGetValue <T>(IPublishedContent content, string alias, string?culture, string?segment, Fallback fallback, T defaultValue, out T?value, out IPublishedProperty?noValueProperty) { value = default; noValueProperty = default; return(false); }
#pragma warning restore 0109 // ctor public Logo(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 public Product(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 // ctor public Event(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 public ContentPage(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 public People(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 public NavigationBase(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 public Person(IPublishedContent content) : base(content) { }
/// <inheritdoc/> public override object Map(IPublishedContent content, object value) { value = value is Picker picker ? picker.SavedValue : value; return(base.Map(content, value)); }
#pragma warning restore 0109 public Blogpost(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 public IndividualJobPage(IPublishedContent content) : base(content) { }
#pragma warning restore 0109 public Feature(IPublishedContent content) : base(content) { }
public static IEnumerable <IPublishedContent> ListViewOrTreeChildren(this IPublishedContent content, bool isListView, string alias = null) { var contentTypeAliases = content.FindListViewContentTypeAliases(alias); return(content.Children(c => contentTypeAliases.IsInListView(c.DocumentTypeAlias) == isListView)); }
#pragma warning restore 0109 public Post(IPublishedContent content) : base(content) { }
public static IEnumerable <IPublishedContent> ListViewChildren(this IPublishedContent content, string alias = null) { return(content.ListViewOrTreeChildren(true, alias)); }
internal DynamicPublishedContent(IPublishedContent content, DynamicPublishedContentList contentList) { PublishedContent = content; _contentList = contentList; }
/// <summary> /// /// </summary> /// <param name="node"></param> /// <returns></returns> public List <UserGroupPermissionsPoco> GetRecursivePermissionsForNode(IPublishedContent node) { List <UserGroupPermissionsPoco> permissions = GetPermissionsForNode(node); return(permissions); }
public static IEnumerable <IPublishedContent> TreeChildren(this IPublishedContent content) { return(content.ListViewOrTreeChildren(false)); }
// ctor public UmbracoMediaAudio(IPublishedContent content, IPublishedValueFallback publishedValueFallback) : base(content, publishedValueFallback) { _publishedValueFallback = publishedValueFallback; }
public static ITemplate GetTemplate(this IPublishedContent content) { return(ApplicationContext.Current.Services.FileService.GetTemplate(content.TemplateId)); }