private string GetContentPath(IUmbracoEntity item) { if (item == null) { return(""); } var path = string.Empty; if (item.ParentId > -1) { var parent = Services.EntityService.Get(item.ParentId); if (parent != null) { path += GetContentPath(parent); } } if (!string.IsNullOrWhiteSpace(path)) { return(path + " > " + item.Name); } return(item.Name); }
/// <summary> /// Returns a collection of all menu items that can be on a content node /// </summary> /// <param name="item"></param> /// <returns></returns> protected MenuItemCollection GetAllNodeMenuItems(IUmbracoEntity item) { var menu = new MenuItemCollection(); AddActionNode <ActionNew>(item, menu, opensDialog: true); AddActionNode <ActionDelete>(item, menu, opensDialog: true); AddActionNode <ActionCreateBlueprintFromContent>(item, menu, opensDialog: true); AddActionNode <ActionMove>(item, menu, true, opensDialog: true); AddActionNode <ActionCopy>(item, menu, opensDialog: true); AddActionNode <ActionSort>(item, menu, true); AddActionNode <ActionAssignDomain>(item, menu, opensDialog: true); AddActionNode <ActionRights>(item, menu, opensDialog: true); AddActionNode <ActionProtect>(item, menu, true, opensDialog: true); if (EmailSender.CanSendRequiredEmail) { menu.Items.Add(new MenuItem("notify", Services.TextService) { Icon = "megaphone", SeparatorBefore = true, OpensDialog = true }); } if ((item is DocumentEntitySlim documentEntity && documentEntity.IsContainer) == false) { menu.Items.Add(new RefreshNode(Services.TextService, true)); } return(menu); }
private int GetTopNodeId(IUmbracoEntity entity) { int id; var parts = entity.Path.Split(Comma, StringSplitOptions.RemoveEmptyEntries); return(parts.Length >= 2 && int.TryParse(parts[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out id) ? id : 0); }
/// <summary> /// Returns a collection of all menu items that can be on a content node /// </summary> /// <param name="item"></param> /// <returns></returns> protected MenuItemCollection GetAllNodeMenuItems(IUmbracoEntity item) { MenuItemCollection menu = _menuItemCollectionFactory.Create(); AddActionNode <ActionNew>(item, menu, opensDialog: true, useLegacyIcon: false); AddActionNode <ActionDelete>(item, menu, opensDialog: true, useLegacyIcon: false); AddActionNode <ActionCreateBlueprintFromContent>(item, menu, opensDialog: true, useLegacyIcon: false); AddActionNode <ActionMove>(item, menu, hasSeparator: true, opensDialog: true, useLegacyIcon: false); AddActionNode <ActionCopy>(item, menu, opensDialog: true, useLegacyIcon: false); AddActionNode <ActionSort>(item, menu, hasSeparator: true, opensDialog: true, useLegacyIcon: false); AddActionNode <ActionAssignDomain>(item, menu, opensDialog: true, useLegacyIcon: false); AddActionNode <ActionRights>(item, menu, opensDialog: true, useLegacyIcon: false); AddActionNode <ActionProtect>(item, menu, hasSeparator: true, opensDialog: true, useLegacyIcon: false); if (_emailSender.CanSendRequiredEmail()) { menu.Items.Add(new MenuItem("notify", LocalizedTextService) { Icon = "icon-megaphone", SeparatorBefore = true, OpensDialog = true, UseLegacyIcon = false }); } if ((item is DocumentEntitySlim documentEntity && documentEntity.IsContainer) == false) { menu.Items.Add(new RefreshNode(LocalizedTextService, true)); } return(menu); }
/// <summary> /// Returns a collection of all menu items that can be on a content node /// </summary> /// <param name="item"></param> /// <returns></returns> protected MenuItemCollection GetAllNodeMenuItems(IUmbracoEntity item) { var menu = _menuItemCollectionFactory.Create(); AddActionNode <ActionNew>(item, menu, opensDialog: true); AddActionNode <ActionDelete>(item, menu, opensDialog: true); AddActionNode <ActionCreateBlueprintFromContent>(item, menu, opensDialog: true); AddActionNode <ActionMove>(item, menu, true, opensDialog: true); AddActionNode <ActionCopy>(item, menu, opensDialog: true); AddActionNode <ActionSort>(item, menu, true, opensDialog: true); AddActionNode <ActionAssignDomain>(item, menu, opensDialog: true); AddActionNode <ActionRights>(item, menu, opensDialog: true); AddActionNode <ActionProtect>(item, menu, true, opensDialog: true); if (_emailSender.CanSendRequiredEmail()) { AddActionNode <ActionNotify>(item, menu, true, opensDialog: true); } if ((item is DocumentEntitySlim documentEntity && documentEntity.IsContainer) == false) { menu.Items.Add(new RefreshNode(LocalizedTextService, true)); } return(menu); }
/// <summary> /// Creates a tree node for a content item based on an UmbracoEntity /// </summary> /// <param name="e"></param> /// <param name="parentId"></param> /// <param name="queryStrings"></param> /// <returns></returns> protected override TreeNode GetSingleTreeNode(IUmbracoEntity e, string parentId, FormDataCollection queryStrings) { var entity = (UmbracoEntity)e; //Special check to see if it ia a container, if so then we'll hide children. var isContainer = e.IsContainer(); // && (queryStrings.Get("isDialog") != "true"); var node = CreateTreeNode( e.Id.ToInvariantString(), parentId, queryStrings, e.Name, entity.ContentTypeIcon, entity.HasChildren && (isContainer == false)); node.AdditionalData.Add("contentType", entity.ContentTypeAlias); if (isContainer) { node.SetContainerStyle(); node.AdditionalData.Add("isContainer", true); } return(node); }
public ContentAccess CheckPermissions( IUmbracoEntity entity, IUser user, IReadOnlyList <char> permissionsToCheck) { if (user == null) { throw new ArgumentNullException(nameof(user)); } if (entity == null) { return(ContentAccess.NotFound); } var hasPathAccess = user.HasContentPathAccess(entity, _entityService, _appCaches); if (hasPathAccess == false) { return(ContentAccess.Denied); } if (permissionsToCheck == null || permissionsToCheck.Count == 0) { return(ContentAccess.Granted); } //get the implicit/inherited permissions for the user for this path return(CheckPermissionsPath(entity.Path, user, permissionsToCheck) ? ContentAccess.Granted : ContentAccess.Denied); }
/// <summary> /// Relates two objects that are based on the <see cref="IUmbracoEntity"/> interface. /// </summary> /// <param name="parent">Parent entity</param> /// <param name="child">Child entity</param> /// <param name="relationType">The type of relation to create</param> /// <returns>The created <see cref="Relation"/></returns> public IRelation Relate(IUmbracoEntity parent, IUmbracoEntity child, IRelationType relationType) { //Ensure that the RelationType has an indentity before using it to relate two entities if (relationType.HasIdentity == false) { Save(relationType); } var relation = new Relation(parent.Id, child.Id, relationType); using (var uow = UowProvider.GetUnitOfWork()) { var repository = RepositoryFactory.CreateRelationRepository(uow); var saveEventArgs = new SaveEventArgs <IRelation>(relation); if (uow.Events.DispatchCancelable(SavingRelation, this, saveEventArgs)) { uow.Commit(); return(relation); } repository.AddOrUpdate(relation); uow.Commit(); saveEventArgs.CanCancel = false; uow.Events.Dispatch(SavedRelation, this, saveEventArgs); return(relation); } }
/// <summary> /// Returns a collection of all menu items that can be on a content node /// </summary> /// <param name="item"></param> /// <returns></returns> protected MenuItemCollection GetAllNodeMenuItems(IUmbracoEntity item) { var menu = new MenuItemCollection(); menu.Items.Add <ActionNew>(ui.Text("actions", ActionNew.Instance.Alias)); menu.Items.Add <ActionDelete>(ui.Text("actions", ActionDelete.Instance.Alias)); menu.Items.Add <ActionCreateBlueprintFromContent>(ui.Text("actions", ActionCreateBlueprintFromContent.Instance.Alias)); //need to ensure some of these are converted to the legacy system - until we upgrade them all to be angularized. menu.Items.Add <ActionMove>(ui.Text("actions", ActionMove.Instance.Alias), true); menu.Items.Add <ActionCopy>(ui.Text("actions", ActionCopy.Instance.Alias)); menu.Items.Add <ActionChangeDocType>(ui.Text("actions", ActionChangeDocType.Instance.Alias)).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add <ActionSort>(ui.Text("actions", ActionSort.Instance.Alias), true).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add <ActionRollback>(ui.Text("actions", ActionRollback.Instance.Alias)).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add <ActionAudit>(ui.Text("actions", ActionAudit.Instance.Alias)).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add <ActionPublish>(ui.Text("actions", ActionPublish.Instance.Alias), true).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add <ActionToPublish>(ui.Text("actions", ActionToPublish.Instance.Alias)).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add <ActionAssignDomain>(ui.Text("actions", ActionAssignDomain.Instance.Alias)).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add <ActionRights>(ui.Text("actions", ActionRights.Instance.Alias), true); menu.Items.Add <ActionProtect>(ui.Text("actions", ActionProtect.Instance.Alias), true).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add <ActionNotify>(ui.Text("actions", ActionNotify.Instance.Alias), true).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add <ActionSendToTranslate>(ui.Text("actions", ActionSendToTranslate.Instance.Alias)).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add <RefreshNode, ActionRefresh>(ui.Text("actions", ActionRefresh.Instance.Alias), true); return(menu); }
/// <summary> /// Relates two objects that are based on the <see cref="IUmbracoEntity"/> interface. /// </summary> /// <param name="parent">Parent entity</param> /// <param name="child">Child entity</param> /// <param name="relationType">The type of relation to create</param> /// <returns>The created <see cref="Relation"/></returns> public IRelation Relate(IUmbracoEntity parent, IUmbracoEntity child, IRelationType relationType) { //Ensure that the RelationType has an indentity before using it to relate two entities if (relationType.HasIdentity == false) { Save(relationType); } var relation = new Relation(parent.Id, child.Id, relationType); if (SavingRelation.IsRaisedEventCancelled(new SaveEventArgs <IRelation>(relation), this)) { return(relation); } var uow = UowProvider.GetUnitOfWork(); using (var repository = RepositoryFactory.CreateRelationRepository(uow)) { repository.AddOrUpdate(relation); uow.Commit(); } SavedRelation.RaiseEvent(new SaveEventArgs <IRelation>(relation, false), this); return(relation); }
/// <summary> /// Relates two objects that are based on the <see cref="IUmbracoEntity"/> interface. /// </summary> /// <param name="parent">Parent entity</param> /// <param name="child">Child entity</param> /// <param name="relationTypeAlias">Alias of the type of relation to create</param> /// <returns>The created <see cref="Relation"/></returns> public IRelation Relate(IUmbracoEntity parent, IUmbracoEntity child, string relationTypeAlias) { var relationType = GetRelationTypeByAlias(relationTypeAlias); if (relationType == null || string.IsNullOrEmpty(relationType.Alias)) { throw new ArgumentNullException(string.Format("No RelationType with Alias '{0}' exists.", relationTypeAlias)); } var relation = new Relation(parent.Id, child.Id, relationType); if (SavingRelation.IsRaisedEventCancelled(new SaveEventArgs <IRelation>(relation), this)) { return(relation); } var uow = UowProvider.GetUnitOfWork(); using (var repository = RepositoryFactory.CreateRelationRepository(uow)) { repository.AddOrUpdate(relation); uow.Commit(); } SavedRelation.RaiseEvent(new SaveEventArgs <IRelation>(relation, false), this); return(relation); }
/// <summary> /// Returns a <see cref="TreeNode"/> for the <see cref="IUmbracoEntity"/> and /// attaches some meta data to the node if the user doesn't have start node access to it when in dialog mode /// </summary> /// <param name="e"></param> /// <param name="parentId"></param> /// <param name="queryStrings"></param> /// <returns></returns> internal TreeNode GetSingleTreeNodeWithAccessCheck(IUmbracoEntity e, string parentId, FormDataCollection queryStrings, int[] startNodeIds, string[] startNodePaths, bool ignoreUserStartNodes) { bool hasPathAccess; var entityIsAncestorOfStartNodes = UserExtensions.IsInBranchOfStartNode(e.Path, startNodeIds, startNodePaths, out hasPathAccess); if (ignoreUserStartNodes == false && entityIsAncestorOfStartNodes == false) { return(null); } var treeNode = GetSingleTreeNode(e, parentId, queryStrings); if (treeNode == null) { //this means that the user has NO access to this node via permissions! They at least need to have browse permissions to see //the node so we need to return null; return(null); } if (ignoreUserStartNodes == false && hasPathAccess == false) { treeNode.AdditionalData["noAccess"] = true; } return(treeNode); }
/// <summary> /// Returns a collection of all menu items that can be on a content node /// </summary> /// <param name="item"></param> /// <returns></returns> protected MenuItemCollection GetAllNodeMenuItems(IUmbracoEntity item) { var menu = new MenuItemCollection(); AddActionNode <ActionNew>(item, menu, opensDialog: true); AddActionNode <ActionDelete>(item, menu, opensDialog: true); AddActionNode <ActionCreateBlueprintFromContent>(item, menu, opensDialog: true); AddActionNode <ActionMove>(item, menu, true, opensDialog: true); AddActionNode <ActionCopy>(item, menu, opensDialog: true); AddActionNode <ActionSort>(item, menu, true); AddActionNode <ActionAssignDomain>(item, menu, opensDialog: true); AddActionNode <ActionRights>(item, menu, opensDialog: true); //fixme - conver this editor to angular AddActionNode <ActionProtect>(item, menu, true, convert: true, opensDialog: true); menu.Items.Add(new MenuItem("notify", Services.TextService) { Icon = "megaphone", SeperatorBefore = true, OpensDialog = true }); menu.Items.Add(new RefreshNode(Services.TextService, true)); return(menu); }
internal void ConvertLegacyMenuItem(IUmbracoEntity item, string nodeType, string currentSection) { // try to get a URL/title from the legacy action, // in some edge cases, item can be null so we'll just convert those to "-1" and "" for id and name since these edge cases don't need that. var attempt = LegacyTreeDataConverter.GetUrlAndTitleFromLegacyAction(Action, item == null ? "-1" : item.Id.ToInvariantString(), nodeType, item == null ? "" : item.Name, currentSection); if (attempt) { var action = attempt.Result; LaunchDialogUrl(action.Url, action.DialogTitle); } else { // if that doesn't work, try to get the legacy confirm view var attempt2 = LegacyTreeDataConverter.GetLegacyConfirmView(Action); if (attempt2) { var view = attempt2.Result; var textService = Current.Services.TextService; LaunchDialogView(view, textService.Localize("defaultdialogs/confirmdelete") + " '" + (item == null ? "" : item.Name) + "' ?"); } } }
/// <summary> /// Relates two objects that are based on the <see cref="IUmbracoEntity"/> interface. /// </summary> /// <param name="parent">Parent entity</param> /// <param name="child">Child entity</param> /// <param name="relationTypeAlias">Alias of the type of relation to create</param> /// <returns>The created <see cref="Relation"/></returns> public IRelation Relate(IUmbracoEntity parent, IUmbracoEntity child, string relationTypeAlias) { var relationType = GetRelationTypeByAlias(relationTypeAlias); if (relationType == null || string.IsNullOrEmpty(relationType.Alias)) { throw new ArgumentNullException(string.Format("No RelationType with Alias '{0}' exists.", relationTypeAlias)); } var relation = new Relation(parent.Id, child.Id, relationType); using (var uow = UowProvider.GetUnitOfWork()) { var saveEventArgs = new SaveEventArgs <IRelation>(relation); if (uow.Events.DispatchCancelable(SavingRelation, this, saveEventArgs)) { uow.Commit(); return(relation); } var repository = RepositoryFactory.CreateRelationRepository(uow); repository.AddOrUpdate(relation); uow.Commit(); saveEventArgs.CanCancel = false; uow.Events.Dispatch(SavedRelation, this, saveEventArgs); return(relation); } }
/// <summary> /// Does a quick check on the entity's set path to ensure that it's valid and consistent /// </summary> /// <param name="entity"></param> /// <returns></returns> public static bool ValidatePath(this IUmbracoEntity entity) { // don't validate if it's empty and it has no id if (entity.HasIdentity == false && entity.Path.IsNullOrWhiteSpace()) { return(true); } if (entity.Path.IsNullOrWhiteSpace()) { return(false); } var pathParts = entity.Path.Split(Constants.CharArrays.Comma, StringSplitOptions.RemoveEmptyEntries); if (pathParts.Length < 2) { // a path cannot be less than 2 parts, at a minimum it must be root (-1) and it's own id return(false); } if (entity.ParentId != default && pathParts[^ 2] != entity.ParentId.ToInvariantString()) { // the 2nd last id in the path must be it's parent id return(false); } return(true); }
private int GetTopNodeId(IUmbracoEntity entity) { int id; var parts = entity.Path.Split(Comma, StringSplitOptions.RemoveEmptyEntries); return(parts.Length >= 2 && int.TryParse(parts[1], out id) ? id : 0); }
public static void ClearIndexingStatus(this IUmbracoEntity entity) { if (entity.AdditionalData.ContainsKey(Key)) { entity.AdditionalData.Remove(Key); } }
internal Media(IUmbracoEntity entity, bool noSetup = true) : base(entity) { if (noSetup == false) { setupNode(); } }
/// <summary> /// Returns true or false if the current user has access to the node based on the user's allowed start node (path) access /// </summary> /// <param name="entity"></param> /// <param name="queryStrings"></param> /// <returns></returns> protected bool HasPathAccess(IUmbracoEntity entity, FormDataCollection queryStrings) { if (entity == null) { return(false); } return(Security.CurrentUser.HasPathAccess(entity, Services.EntityService, RecycleBinId)); }
public static bool HasContentPathAccess(this IUser user, IUmbracoEntity entity, IEntityService entityService, AppCaches appCaches) { if (entity == null) { throw new ArgumentNullException(nameof(entity)); } return(ContentPermissions.HasPathAccess(entity.Path, user.CalculateContentStartNodeIds(entityService, appCaches), Constants.System.RecycleBinContent)); }
public static IndexingStatus GetIndexingStatus(this IUmbracoEntity entity) { if (!entity.AdditionalData.ContainsKey(Key)) { entity.AdditionalData.Add(Key, new IndexingStatus()); } return(entity.AdditionalData[Key] as IndexingStatus); }
protected override string GetItemFileName(IUmbracoEntity item, bool useGuid) { if (useGuid) { return(item.Key.ToString()); } return(item.Name.ToSafeAlias()); }
/// <summary> /// Helper method to create tree nodes and automatically generate the json url + UDI /// </summary> /// <param name="entity"></param> /// <param name="entityObjectType"></param> /// <param name="parentId"></param> /// <param name="queryStrings"></param> /// <param name="icon"></param> /// <param name="hasChildren"></param> /// <returns></returns> public TreeNode CreateTreeNode(IUmbracoEntity entity, Guid entityObjectType, string parentId, FormDataCollection queryStrings, string icon, bool hasChildren) { var treeNode = CreateTreeNode(entity.Id.ToInvariantString(), parentId, queryStrings, entity.Name, icon); treeNode.Udi = Udi.Create(UmbracoObjectTypesExtensions.GetUdiType(entityObjectType), entity.Key); treeNode.HasChildren = hasChildren; return(treeNode); }
public static object GetAdditionalDataValueIgnoreCase(this IUmbracoEntity entity, string key, object defaultVal) { if (entity.AdditionalData.ContainsKeyIgnoreCase(key) == false) { return(defaultVal); } return(entity.AdditionalData.GetValueIgnoreCase(key, defaultVal)); }
internal static bool HasMediaPathAccess(this IUser user, IUmbracoEntity entity, IEntityService entityService) { if (entity == null) { throw new ArgumentNullException(nameof(entity)); } return(ContentPermissionsHelper.HasPathAccess(entity.Path, user.CalculateMediaStartNodeIds(entityService), Constants.System.RecycleBinMedia)); }
internal static void SendNotification(this INotificationService service, IUmbracoEntity entity, IAction action, UmbracoContext umbracoContext) { if (umbracoContext == null) { LogHelper.Warn(typeof(NotificationServiceExtensions), "Cannot send notifications, there is no current UmbracoContext"); return; } service.SendNotification(entity, action, umbracoContext, umbracoContext.Application); }
/// <summary> /// Checks if the user has access to the specified node and permissions set /// </summary> /// <param name="nodeId"></param> /// <param name="user"></param> /// <param name="userService"></param> /// <param name="entityService"></param> /// <param name="entity">The <see cref="IUmbracoEntity"/> item resolved if one was found for the id</param> /// <param name="permissionsToCheck"></param> /// <returns></returns> public ContentAccess CheckPermissions( int nodeId, IUser user, out IUmbracoEntity entity, IReadOnlyList <char> permissionsToCheck = null) { if (user == null) { throw new ArgumentNullException(nameof(user)); } if (permissionsToCheck == null) { permissionsToCheck = Array.Empty <char>(); } bool?hasPathAccess = null; entity = null; if (nodeId == Constants.System.Root) { hasPathAccess = user.HasContentRootAccess(_entityService, _appCaches); } else if (nodeId == Constants.System.RecycleBinContent) { hasPathAccess = user.HasContentBinAccess(_entityService, _appCaches); } if (hasPathAccess.HasValue) { return(hasPathAccess.Value ? ContentAccess.Granted : ContentAccess.Denied); } entity = _entityService.Get(nodeId, UmbracoObjectTypes.Document); if (entity == null) { return(ContentAccess.NotFound); } hasPathAccess = user.HasContentPathAccess(entity, _entityService, _appCaches); if (hasPathAccess == false) { return(ContentAccess.Denied); } if (permissionsToCheck == null || permissionsToCheck.Count == 0) { return(ContentAccess.Granted); } //get the implicit/inherited permissions for the user for this path return(CheckPermissionsPath(entity.Path, user, permissionsToCheck) ? ContentAccess.Granted : ContentAccess.Denied); }
/// <summary> /// Returns true or false if the current user has access to the node based on the user's allowed start node (path) access /// </summary> /// <param name="entity"></param> /// <param name="queryStrings"></param> /// <returns></returns> protected bool HasPathAccess(IUmbracoEntity entity, FormCollection queryStrings) { if (entity == null) { return(false); } return(RecycleBinId == Constants.System.RecycleBinContent ? _backofficeSecurityAccessor.BackOfficeSecurity.CurrentUser.HasContentPathAccess(entity, _entityService, _appCaches) : _backofficeSecurityAccessor.BackOfficeSecurity.CurrentUser.HasMediaPathAccess(entity, _entityService, _appCaches)); }
/// <summary> /// Returns true or false if the current user has access to the node based on the user's allowed start node (path) access /// </summary> /// <param name="entity"></param> /// <param name="queryStrings"></param> /// <returns></returns> protected bool HasPathAccess(IUmbracoEntity entity, FormDataCollection queryStrings) { if (entity == null) { return(false); } return(RecycleBinId == Constants.System.RecycleBinContent ? Security.CurrentUser.HasContentPathAccess(entity, Services.EntityService) : Security.CurrentUser.HasMediaPathAccess(entity, Services.EntityService)); }
private string GetPath(IUmbracoEntity item) { var path = item.Name; if (item.ParentId != -1) { var parent = _entityService.Get(item.ParentId); if (parent != null) { path = GetPath(parent) + @"\" + path; } } return path; }
/// <summary> /// Creates a tree node for a content item based on an UmbracoEntity /// </summary> /// <param name="e"></param> /// <param name="parentId"></param> /// <param name="queryStrings"></param> /// <returns></returns> protected override TreeNode GetSingleTreeNode(IUmbracoEntity e, string parentId, FormDataCollection queryStrings) { var entity = (UmbracoEntity)e; //Special check to see if it ia a container, if so then we'll hide children. var isContainer = entity.AdditionalData.ContainsKey("IsContainer") && entity.AdditionalData["IsContainer"] is bool && (bool)entity.AdditionalData["IsContainer"]; var node = CreateTreeNode( e.Id.ToInvariantString(), parentId, queryStrings, e.Name, entity.ContentTypeIcon, entity.HasChildren && (isContainer == false)); node.AdditionalData.Add("contentType", entity.ContentTypeAlias); if (isContainer) node.SetContainerStyle(); return node; }
/// <summary> /// Returns a collection of all menu items that can be on a content node /// </summary> /// <param name="item"></param> /// <returns></returns> protected MenuItemCollection GetAllNodeMenuItems(IUmbracoEntity item) { var menu = new MenuItemCollection(); menu.Items.Add<ActionNew>(ui.Text("actions", ActionNew.Instance.Alias)); menu.Items.Add<ActionDelete>(ui.Text("actions", ActionDelete.Instance.Alias)); //need to ensure some of these are converted to the legacy system - until we upgrade them all to be angularized. menu.Items.Add<ActionMove>(ui.Text("actions", ActionMove.Instance.Alias), true); menu.Items.Add<ActionCopy>(ui.Text("actions", ActionCopy.Instance.Alias)); menu.Items.Add<ActionSort>(ui.Text("actions", ActionSort.Instance.Alias), true).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add<ActionRollback>(ui.Text("actions", ActionRollback.Instance.Alias)).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add<ActionPublish>(ui.Text("actions", ActionPublish.Instance.Alias), true).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add<ActionToPublish>(ui.Text("actions", ActionToPublish.Instance.Alias)).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add<ActionAssignDomain>(ui.Text("actions", ActionAssignDomain.Instance.Alias)).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add<ActionRights>(ui.Text("actions", ActionRights.Instance.Alias)).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add<ActionProtect>(ui.Text("actions", ActionProtect.Instance.Alias), true).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add<ActionNotify>(ui.Text("actions", ActionNotify.Instance.Alias), true).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add<ActionSendToTranslate>(ui.Text("actions", ActionSendToTranslate.Instance.Alias)).ConvertLegacyMenuItem(item, "content", "content"); menu.Items.Add<RefreshNode, ActionRefresh>(ui.Text("actions", ActionRefresh.Instance.Alias), true); return menu; }
protected abstract TreeNode GetSingleTreeNode(IUmbracoEntity e, string parentId, FormDataCollection queryStrings);
/// <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 MenuItems 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 bool CanUserAccessNode(IUmbracoEntity doc, IEnumerable<MenuItem> allowedUserOptions) { return allowedUserOptions.Select(x => x.Action).OfType<ActionBrowse>().Any(); }
internal IEnumerable<MenuItem> GetAllowedUserMenuItemsForNode(IUmbracoEntity dd) { var actions = global::umbraco.BusinessLogic.Actions.Action.FromString(UmbracoUser.GetPermissions(dd.Path)); // A user is allowed to delete their own stuff if (dd.CreatorId == UmbracoUser.Id && actions.Contains(ActionDelete.Instance) == false) actions.Add(ActionDelete.Instance); return actions.Select(x => new MenuItem(x)); }
internal void ConvertLegacyMenuItem(IUmbracoEntity item, string nodeType, string currentSection) { //First try to get a URL/title from the legacy action, // if that doesn't work, try to get the legacy confirm view //in some edge cases, item can be null so we'll just convert those to "-1" and "" for id and name since these edge cases don't need that. Attempt .Try(LegacyTreeDataConverter.GetUrlAndTitleFromLegacyAction(Action, item == null ? "-1" : item.Id.ToInvariantString(), nodeType, item == null ? "" : item.Name, currentSection), action => LaunchDialogUrl(action.Url, action.DialogTitle)) .OnFailure(() => LegacyTreeDataConverter.GetLegacyConfirmView(Action, currentSection), view => LaunchDialogView( view, ui.GetText("defaultdialogs", "confirmdelete") + " '" + item.Name + "' ?")); }
private string GetFullPath(IUmbracoEntity entity) { var content = entity as IContent; var ancestorsPath = ""; if (content != null) ancestorsPath = String.Join(" " + configuration.BreadcrumbSeparator + " ", content.Ancestors().Select(x => x.Name)); return String.Format("{0} {1} {2}", ancestorsPath, configuration.BreadcrumbSeparator, entity.Name); }
protected internal Content(IUmbracoEntity entity) : base(entity) { }
/// <summary> /// Creates a tree node for a content item based on an UmbracoEntity /// </summary> /// <param name="e"></param> /// <param name="parentId"></param> /// <param name="queryStrings"></param> /// <returns></returns> protected override TreeNode GetSingleTreeNode(IUmbracoEntity e, string parentId, FormDataCollection queryStrings) { var entity = (UmbracoEntity) e; var allowedUserOptions = GetAllowedUserMenuItemsForNode(e); if (CanUserAccessNode(e, allowedUserOptions)) { //Special check to see if it ia a container, if so then we'll hide children. var isContainer = e.AdditionalData.ContainsKey("IsContainer") && e.AdditionalData["IsContainer"] is bool && (bool)e.AdditionalData["IsContainer"]; var node = CreateTreeNode( e.Id.ToInvariantString(), parentId, queryStrings, e.Name, entity.ContentTypeIcon, entity.HasChildren && (isContainer == false)); node.AdditionalData.Add("contentType", entity.ContentTypeAlias); if (isContainer) node.SetContainerStyle(); if (entity.IsPublished == false) node.SetNotPublishedStyle(); if (entity.HasPendingChanges) node.SetHasUnpublishedVersionStyle(); if (Access.IsProtected(e.Id, e.Path)) node.SetProtectedStyle(); return node; } return null; }
private Node GenerateJsonForTree(IUmbracoEntity content) { var children = Services.EntityService.GetChildren(content.Id); var isFolder = children.Any(); var temp = new Node { title = content.Name, key = content.Id.ToString(), folder = isFolder, lazy = isFolder }; return temp; }
/// <summary> /// Internal initialization of a legacy Document object using the new IUmbracoEntity object /// </summary> /// <param name="entity"></param> /// <param name="noSetup"></param> internal Document(IUmbracoEntity entity, bool noSetup = true) : base(entity) { if(noSetup == false) setupNode(); }
/// <summary> /// Relates two objects that are based on the <see cref="IUmbracoEntity"/> interface. /// </summary> /// <param name="parent">Parent entity</param> /// <param name="child">Child entity</param> /// <param name="relationType">The type of relation to create</param> /// <returns>The created <see cref="Relation"/></returns> public Relation Relate(IUmbracoEntity parent, IUmbracoEntity child, RelationType relationType) { //Ensure that the RelationType has an indentity before using it to relate two entities if(relationType.HasIdentity == false) Save(relationType); var relation = new Relation(parent.Id, child.Id, relationType); var uow = _uowProvider.GetUnitOfWork(); using (var repository = _repositoryFactory.CreateRelationRepository(uow)) { repository.AddOrUpdate(relation); uow.Commit(); return relation; } }
/// <summary> /// Relates two objects that are based on the <see cref="IUmbracoEntity"/> interface. /// </summary> /// <param name="parent">Parent entity</param> /// <param name="child">Child entity</param> /// <param name="relationTypeAlias">Alias of the type of relation to create</param> /// <returns>The created <see cref="Relation"/></returns> public Relation Relate(IUmbracoEntity parent, IUmbracoEntity child, string relationTypeAlias) { var relationType = GetRelationTypeByAlias(relationTypeAlias); if(relationType == null || string.IsNullOrEmpty(relationType.Alias)) throw new ArgumentNullException(string.Format("No RelationType with Alias '{0}' exists.", relationTypeAlias)); var relation = new Relation(parent.Id, child.Id, relationType); var uow = _uowProvider.GetUnitOfWork(); using (var repository = _repositoryFactory.CreateRelationRepository(uow)) { repository.AddOrUpdate(relation); uow.Commit(); return relation; } }