From feefb052fd8b0e4fd5a129227bb4511faccc6e3b Mon Sep 17 00:00:00 2001 From: Shannon Date: Mon, 17 Feb 2014 17:45:59 +1100 Subject: [PATCH] Updates the BulkInsertRecords method to optionally close the trans - shouldn't by default. Updates how permissions are handled in the new services and exposes another method, ensures it's all wrapped in trans and ensures that cache is cleared properly. Fixes: U4-4213 "Replace child node permissions" does not work if all permissions cleared --- .../Persistence/PetaPocoExtensions.cs | 23 +- .../Repositories/ContentRepository.cs | 6 + .../Interfaces/IContentRepository.cs | 6 + .../Interfaces/IUserRepository.cs | 8 + .../Repositories/PermissionRepository.cs | 224 +++++++++--------- .../Repositories/UserRepository.cs | 12 + src/Umbraco.Core/Services/ContentService.cs | 2 + src/Umbraco.Core/Services/DataTypeService.cs | 18 +- src/Umbraco.Core/Services/IUserService.cs | 8 + src/Umbraco.Core/Services/MediaService.cs | 2 + src/Umbraco.Core/Services/MemberService.cs | 2 + src/Umbraco.Core/Services/UserService.cs | 15 ++ .../Persistence/Querying/PetaPocoSqlTests.cs | 19 -- .../Services/PerformanceTests.cs | 2 + .../Cache/CacheRefresherEventHandler.cs | 13 +- .../umbraco/users/UserPermissions.cs | 36 +-- src/umbraco.cms/businesslogic/Permission.cs | 17 +- 17 files changed, 232 insertions(+), 181 deletions(-) diff --git a/src/Umbraco.Core/Persistence/PetaPocoExtensions.cs b/src/Umbraco.Core/Persistence/PetaPocoExtensions.cs index c18ee92d50..6d479b9eb1 100644 --- a/src/Umbraco.Core/Persistence/PetaPocoExtensions.cs +++ b/src/Umbraco.Core/Persistence/PetaPocoExtensions.cs @@ -57,11 +57,20 @@ namespace Umbraco.Core.Persistence using (var tr = db.GetTransaction()) { - db.BulkInsertRecords(collection, tr); + db.BulkInsertRecords(collection, tr, true); } } - public static void BulkInsertRecords(this Database db, IEnumerable collection, Transaction tr) + /// + /// Performs the bulk insertion in the context of a current transaction with an optional parameter to complete the transaction + /// when finished + /// + /// + /// + /// + /// + /// + public static void BulkInsertRecords(this Database db, IEnumerable collection, Transaction tr, bool commitTrans = false) { //don't do anything if there are no records. if (collection.Any() == false) @@ -95,11 +104,17 @@ namespace Umbraco.Core.Persistence } } - tr.Complete(); + if (commitTrans) + { + tr.Complete(); + } } catch { - tr.Dispose(); + if (commitTrans) + { + tr.Dispose(); + } throw; } } diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs index c958886ebc..df652b14b3 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs @@ -530,6 +530,12 @@ namespace Umbraco.Core.Persistence.Repositories return GetByVersion(dto.ContentVersionDto.VersionId); } + /// + /// Assigns one permission to an entity for multiple users + /// + /// + /// + /// public void AssignEntityPermissions(IContent entity, char permission, IEnumerable userIds) { var repo = new PermissionRepository(UnitOfWork, _cacheHelper); diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentRepository.cs index a8cb9a88c5..16044a313d 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentRepository.cs @@ -23,6 +23,12 @@ namespace Umbraco.Core.Persistence.Repositories /// An enumerable list of IEnumerable GetByPublishedVersion(IQuery query); + /// + /// Assigns a single permission to the current content item for the specified user ids + /// + /// + /// + /// void AssignEntityPermissions(IContent entity, char permission, IEnumerable userIds); /// diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IUserRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IUserRepository.cs index ec8be65747..599e69fae7 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IUserRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IUserRepository.cs @@ -47,5 +47,13 @@ namespace Umbraco.Core.Persistence.Repositories /// /// IEnumerable GetUserPermissionsForEntities(int userId, params int[] entityIds); + + /// + /// Assigns the same permission set for a single user to any number of entities + /// + /// + /// + /// + void AssignUserPermissions(int userId, IEnumerable permissions, params int[] entityIds); } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/PermissionRepository.cs b/src/Umbraco.Core/Persistence/Repositories/PermissionRepository.cs index ced8dba66d..fd96dc7a54 100644 --- a/src/Umbraco.Core/Persistence/Repositories/PermissionRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/PermissionRepository.cs @@ -6,6 +6,7 @@ using System.Globalization; using System.Linq; using System.Text; using System.Web.Caching; +using Umbraco.Core.Events; using Umbraco.Core.Models; using Umbraco.Core.Models.EntityBase; using Umbraco.Core.Models.Membership; @@ -13,6 +14,7 @@ using Umbraco.Core.Models.Rdbms; using Umbraco.Core.Persistence.Caching; using Umbraco.Core.Persistence.SqlSyntax; using Umbraco.Core.Persistence.UnitOfWork; +using Umbraco.Core.Services; using CacheKeys = Umbraco.Core.Cache.CacheKeys; using Umbraco.Core.Cache; @@ -21,7 +23,6 @@ namespace Umbraco.Core.Persistence.Repositories /// /// A repository that exposes functionality to modify assigned permissions to a node /// - /// /// internal class PermissionRepository where TEntity : class, IAggregateRoot @@ -41,7 +42,7 @@ namespace Umbraco.Core.Persistence.Repositories /// /// /// - internal IEnumerable GetUserPermissionsForEntities(int userId, params int[] entityIds) + public IEnumerable GetUserPermissionsForEntities(int userId, params int[] entityIds) { var entityIdKey = string.Join(",", entityIds.Select(x => x.ToString(CultureInfo.InvariantCulture))); return _cache.RuntimeCache.GetCacheItem>( @@ -99,7 +100,7 @@ namespace Umbraco.Core.Persistence.Repositories /// /// /// - internal IEnumerable GetPermissionsForEntity(int entityId) + public IEnumerable GetPermissionsForEntity(int entityId) { var sql = new Sql(); sql.Select("*") @@ -112,7 +113,110 @@ namespace Umbraco.Core.Persistence.Repositories return ConvertToPermissionList(result); } - private IEnumerable ConvertToPermissionList(IEnumerable result) + /// + /// Assigns the same permission set for a single user to any number of entities + /// + /// + /// + /// + public void AssignUserPermissions(int userId, IEnumerable permissions, params int[] entityIds) + { + var db = _unitOfWork.Database; + using (var trans = db.GetTransaction()) + { + db.Execute("DELETE FROM umbracoUser2NodePermission WHERE userId=@userId AND nodeId in (@nodeIds)", + new {userId = userId, nodeIds = entityIds}); + + var toInsert = new List(); + foreach (var p in permissions) + { + foreach (var e in entityIds) + { + toInsert.Add(new User2NodePermissionDto + { + NodeId = e, + Permission = p.ToString(CultureInfo.InvariantCulture), + UserId = userId + }); + } + } + + _unitOfWork.Database.BulkInsertRecords(toInsert, trans); + + trans.Complete(); + + //Raise the event + AssignedPermissions.RaiseEvent( + new SaveEventArgs(ConvertToPermissionList(toInsert), false), this); + } + } + + /// + /// Assigns one permission to an entity for multiple users + /// + /// + /// + /// + /// + /// This will first clear the permissions for this entity then re-create them + /// + public void AssignEntityPermissions(TEntity entity, char permission, IEnumerable userIds) + { + var db = _unitOfWork.Database; + using (var trans = db.GetTransaction()) + { + db.Execute("DELETE FROM umbracoUser2NodePermission WHERE nodeId=@nodeId", new {nodeId = entity.Id}); + + var actions = userIds.Select(id => new User2NodePermissionDto + { + NodeId = entity.Id, + Permission = permission.ToString(CultureInfo.InvariantCulture), + UserId = id + }).ToArray(); + + _unitOfWork.Database.BulkInsertRecords(actions, trans); + + trans.Complete(); + + //Raise the event + AssignedPermissions.RaiseEvent( + new SaveEventArgs(ConvertToPermissionList(actions), false), this); + } + } + + /// + /// Assigns permissions to an entity for multiple users/permission entries + /// + /// + /// + /// A key/value pair list containing a userId and a permission to assign + /// + /// + /// This will first clear the permissions for this entity then re-create them + /// + public void AssignEntityPermissions(TEntity entity, IEnumerable> userPermissions) + { + var db = _unitOfWork.Database; + using (var trans = db.GetTransaction()) + { + db.Execute("DELETE FROM umbracoUser2NodePermission WHERE nodeId=@nodeId", new { nodeId = entity.Id }); + + var actions = userPermissions.Select(p => new User2NodePermissionDto + { + NodeId = entity.Id, + Permission = p.Item2, + UserId = p.Item1 + }).ToArray(); + + _unitOfWork.Database.BulkInsertRecords(actions); + + //Raise the event + AssignedPermissions.RaiseEvent( + new SaveEventArgs(ConvertToPermissionList(actions), false), this); + } + } + + private static IEnumerable ConvertToPermissionList(IEnumerable result) { var permissions = new List(); var nodePermissions = result.GroupBy(x => x.NodeId); @@ -128,116 +232,6 @@ namespace Umbraco.Core.Persistence.Repositories return permissions; } - /// - /// Assigns one permission to an entity for multiple users - /// - /// - /// - /// - internal void AssignEntityPermissions(TEntity entity, char permission, IEnumerable userIds) - { - var actions = userIds.Select(id => new User2NodePermissionDto - { - NodeId = entity.Id, - Permission = permission.ToString(CultureInfo.InvariantCulture), - UserId = (int)id - }); - - _unitOfWork.Database.BulkInsertRecords(actions); - } - - /// - /// Assigns permissions to an entity for multiple users/permission entries - /// - /// - /// - /// A key/value pair list containing a userId and a permission to assign - /// - internal void AssignEntityPermissions(TEntity entity, IEnumerable> userPermissions) - { - var actions = userPermissions.Select(p => new User2NodePermissionDto - { - NodeId = entity.Id, - Permission = p.Item2, - UserId = p.Item1 - }); - - _unitOfWork.Database.BulkInsertRecords(actions); - } - - /// - /// Replace permissions for an entity for multiple users - /// - /// - /// - /// - internal void ReplaceEntityPermissions(TEntity entity, string permissions, IEnumerable userIds) - { - _unitOfWork.Database.Update( - GenerateReplaceEntityPermissionsSql(entity.Id, permissions, userIds.ToArray())); - } - - /// - /// An overload to replace entity permissions and all replace all descendant permissions - /// - /// - /// - /// - /// A callback to get the descendant Ids of the current entity - /// - /// - internal void ReplaceEntityPermissions(TEntity entity, string permissions, Func> getDescendantIds, IEnumerable userIds) - { - _unitOfWork.Database.Update( - GenerateReplaceEntityPermissionsSql( - new[] { entity.Id }.Concat(getDescendantIds(entity)).ToArray(), - permissions, - userIds.ToArray())); - } - - internal static string GenerateReplaceEntityPermissionsSql(int entityId, string permissions, int[] userIds) - { - return GenerateReplaceEntityPermissionsSql(new[] { entityId }, permissions, userIds); - } - - internal static string GenerateReplaceEntityPermissionsSql(int[] entityIds, string permissions, int[] userIds) - { - //create the "SET" clause of the update statement - var sqlSet = string.Format("SET {0}={1}", - SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName("permission"), - SqlSyntaxContext.SqlSyntaxProvider.GetQuotedValue(permissions)); - - //build the nodeIds part of the where clause - var sqlNodeWhere = BuildOrClause(entityIds, "nodeId"); - - //build up the userIds part of the where clause - var userWhereBuilder = BuildOrClause(userIds, "userId"); - - var sqlWhere = new Sql(); - sqlWhere.Where(string.Format("{0} AND {1}", sqlNodeWhere, userWhereBuilder)); - - return string.Format("{0} {1}", sqlSet, sqlWhere.SQL); - } - - private static string BuildOrClause(IEnumerable ids, string colName) - { - var asArray = ids.ToArray(); - var userWhereBuilder = new StringBuilder(); - userWhereBuilder.Append("("); - for (var index = 0; index < asArray.Length; index++) - { - var userId = asArray[index]; - userWhereBuilder.Append(SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(colName)); - userWhereBuilder.Append("="); - userWhereBuilder.Append(userId); - if (index < asArray.Length - 1) - { - userWhereBuilder.Append(" OR "); - } - } - userWhereBuilder.Append(")"); - return userWhereBuilder.ToString(); - } - + public static event TypedEventHandler, SaveEventArgs> AssignedPermissions; } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs b/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs index 4e89d67d49..63a2d4917e 100644 --- a/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs @@ -324,6 +324,18 @@ namespace Umbraco.Core.Persistence.Repositories return repo.GetUserPermissionsForEntities(userId, entityIds); } + /// + /// Assigns the same permission set for a single user to any number of entities + /// + /// + /// + /// + public void AssignUserPermissions(int userId, IEnumerable permissions, params int[] entityIds) + { + var repo = new PermissionRepository(UnitOfWork, _cacheHelper); + repo.AssignUserPermissions(userId, permissions, entityIds); + } + #endregion private IEnumerable ConvertFromDtos(IEnumerable dtos) diff --git a/src/Umbraco.Core/Services/ContentService.cs b/src/Umbraco.Core/Services/ContentService.cs index fe5609fdb9..607538decc 100644 --- a/src/Umbraco.Core/Services/ContentService.cs +++ b/src/Umbraco.Core/Services/ContentService.cs @@ -1511,6 +1511,8 @@ namespace Umbraco.Core.Services //bulk insert it into the database uow.Database.BulkInsertRecords(xmlItems, tr); + + tr.Complete(); } Audit.Add(AuditTypes.Publish, "RebuildXmlStructures completed, the xml has been regenerated in the database", 0, -1); diff --git a/src/Umbraco.Core/Services/DataTypeService.cs b/src/Umbraco.Core/Services/DataTypeService.cs index f21b76a899..8a1e41a707 100644 --- a/src/Umbraco.Core/Services/DataTypeService.cs +++ b/src/Umbraco.Core/Services/DataTypeService.cs @@ -214,17 +214,17 @@ namespace Umbraco.Core.Services { using (var uow = _uowProvider.GetUnitOfWork()) { - var sortOrderObj = - uow.Database.ExecuteScalar( - "SELECT max(sortorder) FROM cmsDataTypePreValues WHERE datatypeNodeId = @DataTypeId", new { DataTypeId = id }); - int sortOrder; - if (sortOrderObj == null || int.TryParse(sortOrderObj.ToString(), out sortOrder) == false) - { - sortOrder = 1; - } - using (var transaction = uow.Database.GetTransaction()) { + var sortOrderObj = + uow.Database.ExecuteScalar( + "SELECT max(sortorder) FROM cmsDataTypePreValues WHERE datatypeNodeId = @DataTypeId", new { DataTypeId = id }); + int sortOrder; + if (sortOrderObj == null || int.TryParse(sortOrderObj.ToString(), out sortOrder) == false) + { + sortOrder = 1; + } + foreach (var value in values) { var dto = new DataTypePreValueDto { DataTypeNodeId = id, Value = value, SortOrder = sortOrder }; diff --git a/src/Umbraco.Core/Services/IUserService.cs b/src/Umbraco.Core/Services/IUserService.cs index 644326a1d4..772d399dc9 100644 --- a/src/Umbraco.Core/Services/IUserService.cs +++ b/src/Umbraco.Core/Services/IUserService.cs @@ -53,6 +53,14 @@ namespace Umbraco.Core.Services /// IEnumerable GetPermissions(IUser user, params int[] nodeIds); + /// + /// Assigns the same permission set for a single user to any number of entities + /// + /// + /// + /// + void AssignUserPermissions(int userId, IEnumerable permissions, params int[] entityIds); + #region User types IEnumerable GetAllUserTypes(params int[] ids); diff --git a/src/Umbraco.Core/Services/MediaService.cs b/src/Umbraco.Core/Services/MediaService.cs index b4d8868e5e..7ee4fc6eab 100644 --- a/src/Umbraco.Core/Services/MediaService.cs +++ b/src/Umbraco.Core/Services/MediaService.cs @@ -938,6 +938,8 @@ namespace Umbraco.Core.Services //bulk insert it into the database uow.Database.BulkInsertRecords(xmlItems, tr); + + tr.Complete(); } Audit.Add(AuditTypes.Publish, "RebuildXmlStructures completed, the xml has been regenerated in the database", 0, -1); diff --git a/src/Umbraco.Core/Services/MemberService.cs b/src/Umbraco.Core/Services/MemberService.cs index d7cd655cd8..f7cccd798e 100644 --- a/src/Umbraco.Core/Services/MemberService.cs +++ b/src/Umbraco.Core/Services/MemberService.cs @@ -972,6 +972,8 @@ namespace Umbraco.Core.Services //bulk insert it into the database uow.Database.BulkInsertRecords(xmlItems, tr); + + tr.Complete(); } } } diff --git a/src/Umbraco.Core/Services/UserService.cs b/src/Umbraco.Core/Services/UserService.cs index 96045178f0..98c6448f12 100644 --- a/src/Umbraco.Core/Services/UserService.cs +++ b/src/Umbraco.Core/Services/UserService.cs @@ -398,6 +398,21 @@ namespace Umbraco.Core.Services } } + /// + /// Assigns the same permission set for a single user to any number of entities + /// + /// + /// + /// + public void AssignUserPermissions(int userId, IEnumerable permissions, params int[] entityIds) + { + var uow = _uowProvider.GetUnitOfWork(); + using (var repository = _repositoryFactory.CreateUserRepository(uow)) + { + repository.AssignUserPermissions(userId, permissions, entityIds); + } + } + public IEnumerable GetAllUserTypes(params int[] ids) { var uow = _uowProvider.GetUnitOfWork(); diff --git a/src/Umbraco.Tests/Persistence/Querying/PetaPocoSqlTests.cs b/src/Umbraco.Tests/Persistence/Querying/PetaPocoSqlTests.cs index 7f96dfade2..e97929c625 100644 --- a/src/Umbraco.Tests/Persistence/Querying/PetaPocoSqlTests.cs +++ b/src/Umbraco.Tests/Persistence/Querying/PetaPocoSqlTests.cs @@ -12,25 +12,6 @@ namespace Umbraco.Tests.Persistence.Querying [TestFixture] public class PetaPocoSqlTests : BaseUsingSqlCeSyntax { - [Test] - public void Generate_Replace_Entity_Permissions_Test() - { - // Act - var sql = PermissionRepository.GenerateReplaceEntityPermissionsSql(123, "A", new int[] {10, 11, 12}); - - // Assert - Assert.AreEqual(@"SET [permission]='A' WHERE (([nodeId]=123) AND ([userId]=10 OR [userId]=11 OR [userId]=12))", sql); - } - - [Test] - public void Generate_Replace_Entity_Permissions_With_Descendants_Test() - { - // Act - var sql = PermissionRepository.GenerateReplaceEntityPermissionsSql(new[] { 123, 456 }, "A", new int[] { 10, 11, 12 }); - - // Assert - Assert.AreEqual(@"SET [permission]='A' WHERE (([nodeId]=123 OR [nodeId]=456) AND ([userId]=10 OR [userId]=11 OR [userId]=12))", sql); - } [Test] public void Can_Select_From_With_Type() diff --git a/src/Umbraco.Tests/Services/PerformanceTests.cs b/src/Umbraco.Tests/Services/PerformanceTests.cs index 4a7ad2026a..947a5d4acc 100644 --- a/src/Umbraco.Tests/Services/PerformanceTests.cs +++ b/src/Umbraco.Tests/Services/PerformanceTests.cs @@ -229,6 +229,8 @@ namespace Umbraco.Tests.Services DatabaseContext.Database.BulkInsertRecords(xmlItems, tr); + + tr.Complete(); } } } diff --git a/src/Umbraco.Web/Cache/CacheRefresherEventHandler.cs b/src/Umbraco.Web/Cache/CacheRefresherEventHandler.cs index 791617d8a6..a9b01fb6e5 100644 --- a/src/Umbraco.Web/Cache/CacheRefresherEventHandler.cs +++ b/src/Umbraco.Web/Cache/CacheRefresherEventHandler.cs @@ -1,8 +1,11 @@ using System.Collections.Generic; using Umbraco.Core; using Umbraco.Core.Cache; +using Umbraco.Core.Events; using Umbraco.Core.Models; using Umbraco.Core.Models.EntityBase; +using Umbraco.Core.Models.Membership; +using Umbraco.Core.Persistence.Repositories; using Umbraco.Core.Services; using umbraco; using umbraco.BusinessLogic; @@ -11,6 +14,7 @@ using umbraco.cms.businesslogic.member; using System.Linq; using umbraco.cms.businesslogic.web; using Content = Umbraco.Core.Models.Content; +using DeleteEventArgs = umbraco.cms.businesslogic.DeleteEventArgs; using Macro = umbraco.cms.businesslogic.macro.Macro; using Member = umbraco.cms.businesslogic.member.Member; using Template = umbraco.cms.businesslogic.template.Template; @@ -95,6 +99,7 @@ namespace Umbraco.Web.Cache Permission.New += PermissionNew; Permission.Updated += PermissionUpdated; Permission.Deleted += PermissionDeleted; + PermissionRepository.AssignedPermissions += CacheRefresherEventHandler_AssignedPermissions; //Bind to template events //NOTE: we need to bind to legacy and new API events currently: http://issues.umbraco.org/issue/U4-1979 @@ -423,7 +428,13 @@ namespace Umbraco.Web.Cache #endregion - #region User event handlers + #region User/permissions event handlers + + static void CacheRefresherEventHandler_AssignedPermissions(PermissionRepository sender, SaveEventArgs e) + { + var userIds = e.SavedEntities.Select(x => x.UserId).Distinct(); + userIds.ForEach(x => DistributedCache.Instance.RefreshUserPermissionsCache(x)); + } static void PermissionDeleted(UserPermission sender, DeleteEventArgs e) { diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/users/UserPermissions.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/users/UserPermissions.cs index b8df81f72b..8a5308a24a 100644 --- a/src/Umbraco.Web/umbraco.presentation/umbraco/users/UserPermissions.cs +++ b/src/Umbraco.Web/umbraco.presentation/umbraco/users/UserPermissions.cs @@ -8,6 +8,7 @@ using System.Collections; using System.Web.UI.WebControls; using System.Data.SqlClient; using System.Data; +using Umbraco.Core; using Umbraco.Web; using Umbraco.Web.Security; using umbraco; @@ -27,17 +28,11 @@ namespace umbraco.cms.presentation.user /// public class UserPermissions { - - User m_user; + readonly User _user; public UserPermissions(User user) { - m_user = user; - } - - private static ISqlHelper SqlHelper - { - get { return Application.SqlHelper; } + _user = user; } /// @@ -70,31 +65,32 @@ namespace umbraco.cms.presentation.user //get the complete list of node ids that this change will affect var allNodes = new List(); if (replaceChildren) + { foreach (var nodeId in nodeIDs) { allNodes.Add(nodeId); allNodes.AddRange(FindChildNodes(nodeId)); } + } else + { allNodes.AddRange(nodeIDs); - - //First remove all permissions for all nodes in question - Permission.DeletePermissions(m_user.Id, allNodes.ToArray()); + } //if permissions are to be assigned, then assign them if (permissions.Count > 0) { - foreach (var oPer in permissions) - { - InsertPermissions(allNodes.ToArray(), oPer); - } + ApplicationContext.Current.Services.UserService.AssignUserPermissions( + _user.Id, permissions.Select(x => x.Letter), allNodes.ToArray()); } else { //If there are NO permissions for this node, we need to assign the ActionNull permission otherwise //the node will inherit from it's parent. - InsertPermissions(nodeIDs, ActionNull.Instance); + ApplicationContext.Current.Services.UserService.AssignUserPermissions( + _user.Id, new[] { ActionNull.Instance.Letter }, allNodes.ToArray()); } + } /// @@ -108,7 +104,7 @@ namespace umbraco.cms.presentation.user if (path != "") { //get the user and their permissions - string permissions = m_user.GetPermissions(path); + string permissions = _user.GetPermissions(path); return umbraco.BusinessLogic.Actions.Action.FromString(permissions); } return null; @@ -149,11 +145,5 @@ namespace umbraco.cms.presentation.user } return nodeIds; } - - private void InsertPermissions(IEnumerable nodeIDs, IAction permission) - { - Permission.MakeNew(m_user, nodeIDs.Select(x => new CMSNode(x)), permission.Letter, true); - } - } } \ No newline at end of file diff --git a/src/umbraco.cms/businesslogic/Permission.cs b/src/umbraco.cms/businesslogic/Permission.cs index f45257c288..91fb96630e 100644 --- a/src/umbraco.cms/businesslogic/Permission.cs +++ b/src/umbraco.cms/businesslogic/Permission.cs @@ -2,8 +2,10 @@ using System; using System.Collections; using System.Collections.Specialized; using System.Data; +using System.Globalization; using System.Linq; using System.Runtime.CompilerServices; +using Umbraco.Core; using Umbraco.Core.Events; using umbraco.DataLayer; using umbraco.cms.businesslogic; @@ -170,7 +172,7 @@ namespace umbraco.BusinessLogic } private static string Converter(int from) { - return from.ToString(); + return from.ToString(CultureInfo.InvariantCulture); } /// @@ -189,16 +191,11 @@ namespace umbraco.BusinessLogic [MethodImpl(MethodImplOptions.Synchronized)] public static void UpdateCruds(User user, CMSNode node, string permissions) { - // delete all settings on the node for this user - //false = do not raise events - DeletePermissions(user, node, false); + ApplicationContext.Current.Services.UserService.AssignUserPermissions( + user.Id, + permissions.ToCharArray(), + node.Id); - // Loop through the permissions and create them - foreach (char c in permissions) - { - //false = don't raise events since we'll raise a custom event after - MakeNew(user, node, c, false); - } OnUpdated(new UserPermission(user, node, permissions.ToCharArray()), new SaveEventArgs()); }