internal void SetSourcesAttributes(ref XmlTreeNode treeElement, UmbracoEntity dd) { treeElement.HasChildren = dd.HasChildren; treeElement.Source = IsDialog == false ? GetTreeServiceUrl(dd.Id) : GetTreeDialogUrl(dd.Id); }
/// <summary> /// NOTE: New implementation of the legacy GetLinkValue. This is however a bit quirky as a media item can have multiple "Linkable DataTypes". /// Returns the value for a link in WYSIWYG mode, by default only media items that have a /// DataTypeUploadField are linkable, however, a custom tree can be created which overrides /// this method, or another GUID for a custom data type can be added to the LinkableMediaDataTypes /// list on application startup. /// </summary> /// <param name="entity"></param> /// <returns></returns> internal virtual string GetLinkValue(UmbracoEntity entity) { foreach (var property in entity.UmbracoProperties) { //required for backwards compatibility with v7 with changing the GUID -> alias var controlId = LegacyPropertyEditorIdToAliasConverter.GetLegacyIdFromAlias(property.PropertyEditorAlias, LegacyPropertyEditorIdToAliasConverter.NotFoundLegacyIdResponseBehavior.ReturnNull); if (controlId != null) { if (LinkableMediaDataTypes.Contains(controlId.Value) && string.IsNullOrEmpty(property.Value) == false) return property.Value; } } return ""; }
internal void SetProtectedAttribute(ref XmlTreeNode treeElement, UmbracoEntity dd) { if (Access.IsProtected(dd.Id, dd.Path)) treeElement.IsProtected = true; else treeElement.IsProtected = false; }
internal void SetActionAttribute(ref XmlTreeNode treeElement, UmbracoEntity dd) { // Check for dialog behaviour if (this.DialogMode == TreeDialogModes.fulllink) { string nodeLink = CreateNodeLink(dd); treeElement.Action = String.Format("javascript:openContent('{0}');", nodeLink); } else if (this.DialogMode == TreeDialogModes.locallink) { string nodeLink = string.Format("{{localLink:{0}}}", dd.Id); string nodeText = dd.Name.Replace("'", "\\'"); // try to make a niceurl too string niceUrl = umbraco.library.NiceUrl(dd.Id).Replace("'", "\\'"); ; if (niceUrl != "#" || niceUrl != "") { nodeLink += "|" + niceUrl + "|" + HttpContext.Current.Server.HtmlEncode(nodeText); } else { nodeLink += "||" + HttpContext.Current.Server.HtmlEncode(nodeText); } treeElement.Action = String.Format("javascript:openContent('{0}');", nodeLink); } else if (this.DialogMode == TreeDialogModes.id || this.DialogMode == TreeDialogModes.none) { treeElement.Action = String.Format("javascript:openContent('{0}');", dd.Id.ToString(CultureInfo.InvariantCulture)); } else if (this.IsDialog == false || (this.DialogMode == TreeDialogModes.id)) { if (CurrentUser.GetPermissions(dd.Path).Contains(ActionUpdate.Instance.Letter.ToString(CultureInfo.InvariantCulture))) { treeElement.Action = String.Format("javascript:openContent({0});", dd.Id); } } }
/// <summary> /// Builds a string of actions that the user is able to perform on the current document. /// The list of actions is subject to the user's rights assigned to the document and also /// is dependant on the type of node. /// </summary> /// <param name="dd"></param> /// <returns></returns> internal List<IAction> GetUserActionsForNode(UmbracoEntity dd) { List<IAction> actions = umbraco.BusinessLogic.Actions.Action.FromString(CurrentUser.GetPermissions(dd.Path)); // A user is allowed to delete their own stuff if (dd.CreatorId == CurrentUser.Id && actions.Contains(ActionDelete.Instance) == false) actions.Add(ActionDelete.Instance); return actions; }
internal void SetNonPublishedAttribute(ref XmlTreeNode treeElement, UmbracoEntity dd) { treeElement.NotPublished = false; if (dd.IsPublished) treeElement.NotPublished = dd.HasPendingChanges; else treeElement.NotPublished = true; }
/// <summary> /// Determins if the user has access to view the node/document /// </summary> /// <param name="doc">The Document to check permissions against</param> /// <param name="allowedUserOptions">A list of IActions that the user has permissions to execute on the current document</param> /// <remarks>By default the user must have Browse permissions to see the node in the Content tree</remarks> /// <returns></returns> internal virtual bool CanUserAccessNode(UmbracoEntity doc, List<IAction> allowedUserOptions) { if (allowedUserOptions.Contains(ActionBrowse.Instance)) return true; return false; }
/// <summary> /// Creates the link for the current UmbracoEntity /// </summary> /// <param name="dd"></param> /// <returns></returns> internal string CreateNodeLink(UmbracoEntity dd) { string nodeLink = library.NiceUrl(dd.Id); if (nodeLink == "") { nodeLink = "/" + dd.Id; if (GlobalSettings.UseDirectoryUrls == false) nodeLink += ".aspx"; } return nodeLink; }
/// <summary> /// Creates an XmlTreeNode based on the passed in UmbracoEntity /// </summary> /// <param name="dd"></param> /// <param name="allowedUserOptions"></param> /// <returns></returns> internal XmlTreeNode CreateNode(UmbracoEntity dd, List<IAction> allowedUserOptions) { XmlTreeNode node = XmlTreeNode.Create(this); SetMenuAttribute(ref node, allowedUserOptions); node.NodeID = dd.Id.ToString(); node.Text = dd.Name; SetNonPublishedAttribute(ref node, dd); SetProtectedAttribute(ref node, dd); SetActionAttribute(ref node, dd); SetSourcesAttributes(ref node, dd); if (dd.ContentTypeIcon != null) { node.Icon = dd.ContentTypeIcon; node.OpenIcon = dd.ContentTypeIcon; } if (dd.IsPublished == false) node.Style.DimNode(); if (dd.HasPendingChanges) node.Style.HighlightNode(); return node; }
/// <summary> /// NOTE: New implementation of the legacy GetLinkValue. This is however a bit quirky as a media item can have multiple "Linkable DataTypes". /// Returns the value for a link in WYSIWYG mode, by default only media items that have a /// DataTypeUploadField are linkable, however, a custom tree can be created which overrides /// this method, or another GUID for a custom data type can be added to the LinkableMediaDataTypes /// list on application startup. /// </summary> /// <param name="entity"></param> /// <returns></returns> internal virtual string GetLinkValue(UmbracoEntity entity) { foreach (var property in entity.UmbracoProperties) { if (LinkableMediaDataTypes.Contains(property.DataTypeControlId) && string.IsNullOrEmpty(property.Value) == false) return property.Value; } return ""; }
internal UmbracoEntity Map(dynamic a, UmbracoPropertyDto p) { // Terminating call. Since we can return null from this function // we need to be ready for PetaPoco to callback later with null // parameters if (a == null) return Current; // Is this the same UmbracoEntity as the current one we're processing if (Current != null && Current.Key == a.uniqueID) { // Yes, just add this UmbracoProperty to the current UmbracoEntity's collection if (Current.UmbracoProperties == null) { Current.UmbracoProperties = new List<UmbracoEntity.UmbracoProperty>(); } Current.UmbracoProperties.Add(new UmbracoEntity.UmbracoProperty { PropertyEditorAlias = p.PropertyEditorAlias, Value = p.UmbracoFile }); // Return null to indicate we're not done with this UmbracoEntity yet return null; } // This is a different UmbracoEntity to the current one, or this is the // first time through and we don't have a Tab yet // Save the current UmbracoEntityDto var prev = Current; // Setup the new current UmbracoEntity Current = _factory.BuildEntityFromDynamic(a); //add the property/create the prop list if null Current.UmbracoProperties = new List<UmbracoEntity.UmbracoProperty> { new UmbracoEntity.UmbracoProperty { PropertyEditorAlias = p.PropertyEditorAlias, Value = p.UmbracoFile } }; // Return the now populated previous UmbracoEntity (or null if first time through) return prev; }