diff --git a/src/Umbraco.Core/Models/Membership/IUser.cs b/src/Umbraco.Core/Models/Membership/IUser.cs index 25a4133eb2..97e7e4132f 100644 --- a/src/Umbraco.Core/Models/Membership/IUser.cs +++ b/src/Umbraco.Core/Models/Membership/IUser.cs @@ -19,7 +19,7 @@ namespace Umbraco.Core.Models.Membership bool NoConsole { get; set; } IUserType UserType { get; } - string Permissions { get; set; } + string DefaultPermissions { get; set; } } internal interface IUserProfile : IProfile diff --git a/src/Umbraco.Core/Models/Membership/User.cs b/src/Umbraco.Core/Models/Membership/User.cs index d6b71135ef..ddcc28cccb 100644 --- a/src/Umbraco.Core/Models/Membership/User.cs +++ b/src/Umbraco.Core/Models/Membership/User.cs @@ -91,7 +91,7 @@ namespace Umbraco.Core.Models.Membership [DataMember] public string Language { get; set; } [DataMember] - public string Permissions { get; set; } + public string DefaultPermissions { get; set; } [DataMember] public bool DefaultToLiveEditing { get; set; } diff --git a/src/Umbraco.Core/Persistence/Factories/UserFactory.cs b/src/Umbraco.Core/Persistence/Factories/UserFactory.cs index 6d38db9739..0a046ca7a0 100644 --- a/src/Umbraco.Core/Persistence/Factories/UserFactory.cs +++ b/src/Umbraco.Core/Persistence/Factories/UserFactory.cs @@ -32,7 +32,7 @@ namespace Umbraco.Core.Persistence.Factories Language = dto.UserLanguage, DefaultToLiveEditing = dto.DefaultToLiveEditing, NoConsole = dto.NoConsole, - Permissions = dto.DefaultPermissions + DefaultPermissions = dto.DefaultPermissions }; foreach (var app in dto.User2AppDtos) @@ -62,7 +62,7 @@ namespace Umbraco.Core.Persistence.Factories UserLanguage = entity.Language, UserName = entity.Name, Type = short.Parse(entity.UserType.Id.ToString()), - DefaultPermissions = entity.Permissions, + DefaultPermissions = entity.DefaultPermissions, User2AppDtos = new List() }; diff --git a/src/Umbraco.Core/Persistence/Mappers/UserMapper.cs b/src/Umbraco.Core/Persistence/Mappers/UserMapper.cs index 1a7add097a..5e2947c3a7 100644 --- a/src/Umbraco.Core/Persistence/Mappers/UserMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/UserMapper.cs @@ -33,7 +33,7 @@ namespace Umbraco.Core.Persistence.Mappers CacheMap(src => src.Username, dto => dto.Login); CacheMap(src => src.Password, dto => dto.Password); CacheMap(src => src.Name, dto => dto.UserName); - CacheMap(src => src.Permissions, dto => dto.DefaultPermissions); + CacheMap(src => src.DefaultPermissions, dto => dto.DefaultPermissions); CacheMap(src => src.StartMediaId, dto => dto.MediaStartId); CacheMap(src => src.StartContentId, dto => dto.ContentStartId); CacheMap(src => src.DefaultToLiveEditing, dto => dto.DefaultToLiveEditing); diff --git a/src/Umbraco.Core/Persistence/PetaPoco.cs b/src/Umbraco.Core/Persistence/PetaPoco.cs index 269fea5f9a..d8507ac681 100644 --- a/src/Umbraco.Core/Persistence/PetaPoco.cs +++ b/src/Umbraco.Core/Persistence/PetaPoco.cs @@ -384,7 +384,7 @@ namespace Umbraco.Core.Persistence } // Add a parameter to a DB command - void AddParam(IDbCommand cmd, object item, string ParameterPrefix) + internal void AddParam(IDbCommand cmd, object item, string ParameterPrefix) { // Convert value to from poco type to db type if (Database.Mapper != null && item!=null) diff --git a/src/Umbraco.Core/Persistence/PetaPocoExtensions.cs b/src/Umbraco.Core/Persistence/PetaPocoExtensions.cs index 85ab884857..6faf4d637a 100644 --- a/src/Umbraco.Core/Persistence/PetaPocoExtensions.cs +++ b/src/Umbraco.Core/Persistence/PetaPocoExtensions.cs @@ -1,4 +1,6 @@ using System; +using System.Collections.Generic; +using System.Data; using System.Linq; using Umbraco.Core.Logging; using Umbraco.Core.Models.Rdbms; @@ -28,6 +30,76 @@ namespace Umbraco.Core.Persistence CreateTable(db, overwrite, tableType); } + public static void BulkInsertRecords(this Database db, IEnumerable collection) + { + using (var tr = db.GetTransaction()) + { + try + { + if (SqlSyntaxContext.SqlSyntaxProvider is SqlCeSyntaxProvider) + { + //SqlCe doesn't support bulk insert statements! + + foreach (var poco in collection) + { + db.Insert(poco); + } + + } + else + { + string sql; + using (var cmd = db.GenerateBulkInsertCommand(collection, db.Connection, out sql)) + { + cmd.CommandText = sql; + cmd.ExecuteNonQuery(); + } + } + + tr.Complete(); + } + catch + { + tr.Dispose(); + throw; + } + } + } + + internal static IDbCommand GenerateBulkInsertCommand(this Database db, IEnumerable collection, IDbConnection connection, out string sql) + { + var pd = Database.PocoData.ForType(typeof(T)); + var tableName = db.EscapeTableName(pd.TableInfo.TableName); + + //get all columns but not the primary key if it is auto-incremental + var cols = string.Join(", ", ( + from c in pd.Columns + where c.Value.ResultColumn == false + select tableName + "." + db.EscapeSqlIdentifier(c.Key)) + .ToArray()); + + var cmd = db.CreateCommand(connection, ""); + + var pocoValues = new List(); + var index = 0; + foreach (var poco in collection) + { + var values = new List(); + foreach (var i in pd.Columns) + { + //if (pd.TableInfo.AutoIncrement && i.Key == pd.TableInfo.PrimaryKey) + //{ + // continue; + //} + values.Add(string.Format("{0}{1}", "@", index++)); + db.AddParam(cmd, i.Value.GetValue(poco), "@"); + } + pocoValues.Add("(" + string.Join(",", values.ToArray()) + ")"); + } + sql = string.Format("INSERT INTO {0} ({1}) VALUES {2}", tableName, cols, string.Join(", ", pocoValues)); + return cmd; + } + public static void CreateTable(this Database db, bool overwrite, Type modelType) { var tableDefinition = DefinitionFactory.GetTableDefinition(modelType); @@ -67,7 +139,7 @@ namespace Umbraco.Core.Persistence //Turn on identity insert if db provider is not mysql if (SqlSyntaxContext.SqlSyntaxProvider.SupportsIdentityInsert() && tableDefinition.Columns.Any(x => x.IsIdentity)) db.Execute(new Sql(string.Format("SET IDENTITY_INSERT {0} ON ", SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(tableName)))); - + //Call the NewTable-event to trigger the insert of base/default data NewTable(tableName, db, e); @@ -106,7 +178,7 @@ namespace Umbraco.Core.Persistence public static void DropTable(this Database db) where T : new() { - Type type = typeof (T); + Type type = typeof(T); var tableNameAttribute = type.FirstAttribute(); if (tableNameAttribute == null) throw new Exception( @@ -184,5 +256,5 @@ namespace Umbraco.Core.Persistence } } - internal class TableCreationEventArgs : System.ComponentModel.CancelEventArgs{} + internal class TableCreationEventArgs : System.ComponentModel.CancelEventArgs { } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs index 58b07e1583..a2b720d06d 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs @@ -206,7 +206,7 @@ namespace Umbraco.Core.Persistence.Repositories nodeDto.Level = short.Parse(level.ToString(CultureInfo.InvariantCulture)); nodeDto.SortOrder = sortOrder; var o = Database.IsNew(nodeDto) ? Convert.ToInt32(Database.Insert(nodeDto)) : Database.Update(nodeDto); - + //Update with new correct path nodeDto.Path = string.Concat(parent.Path, ",", nodeDto.NodeId); Database.Update(nodeDto); @@ -217,6 +217,21 @@ namespace Umbraco.Core.Persistence.Repositories entity.SortOrder = sortOrder; entity.Level = level; + + //Assign the same permissions to it as the parent node + // http://issues.umbraco.org/issue/U4-2161 + var parentPermissions = GetPermissionsForEntity(entity.ParentId).ToArray(); + //if there are parent permissions then assign them, otherwise leave null and permissions will become the + // user's default permissions. + if (parentPermissions.Any()) + { + //group by the unique permission and assign then for the users of that permission set. + foreach (var assignedPermission in parentPermissions.GroupBy(x => x.Permission)) + { + AssignEntityPermissions(entity, assignedPermission.Key, assignedPermission.Select(x => (object)x.UserId)); + } + } + //Create the Content specific data - cmsContent var contentDto = dto.ContentVersionDto.ContentDto; contentDto.NodeId = nodeDto.NodeId; diff --git a/src/Umbraco.Core/Persistence/Repositories/PermissionRepository.cs b/src/Umbraco.Core/Persistence/Repositories/PermissionRepository.cs new file mode 100644 index 0000000000..88087c7999 --- /dev/null +++ b/src/Umbraco.Core/Persistence/Repositories/PermissionRepository.cs @@ -0,0 +1,135 @@ +using System; +using System.Collections.Generic; +using System.Dynamic; +using System.Linq; +using System.Text; +using Umbraco.Core.Models; +using Umbraco.Core.Models.EntityBase; +using Umbraco.Core.Models.Membership; +using Umbraco.Core.Models.Rdbms; +using Umbraco.Core.Persistence.Caching; +using Umbraco.Core.Persistence.SqlSyntax; +using Umbraco.Core.Persistence.UnitOfWork; + +namespace Umbraco.Core.Persistence.Repositories +{ + /// + /// A repository that exposes functionality to modify assigned permissions to a node + /// + /// + /// + internal abstract class PermissionRepository : PetaPocoRepositoryBase + where TEntity : class, IAggregateRoot + { + protected PermissionRepository(IDatabaseUnitOfWork work) + : base(work) + { + } + + protected PermissionRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache) + : base(work, cache) + { + } + + protected internal IEnumerable GetPermissionsForEntity(int entityId) + { + var sql = new Sql(); + sql.Select("*") + .From() + .Where(dto => dto.NodeId == entityId); + return Database.Fetch(sql); + } + + /// + /// Assigns permissions to an entity for multiple users + /// + /// + /// + /// + protected internal void AssignEntityPermissions(TEntity entity, string permissions, IEnumerable userIds) + { + var actions = userIds.Select(id => new User2NodePermissionDto + { + NodeId = entity.Id, + Permission = permissions, + UserId = (int)id + }); + + Database.BulkInsertRecords(actions); + } + + /// + /// Replace permissions for an entity for multiple users + /// + /// + /// + /// + protected internal void ReplaceEntityPermissions(TEntity entity, string permissions, IEnumerable userIds) + { + 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 + /// + /// + protected internal void ReplaceEntityPermissions(TEntity entity, string permissions, Func> getDescendantIds, IEnumerable userIds) + { + Database.Update( + GenerateReplaceEntityPermissionsSql( + new[] {entity.Id}.Concat(getDescendantIds(entity)).ToArray(), + permissions, + userIds.ToArray())); + } + + internal static string GenerateReplaceEntityPermissionsSql(int entityId, string permissions, object[] userIds) + { + return GenerateReplaceEntityPermissionsSql(new[] {entityId}, permissions, userIds); + } + + internal static string GenerateReplaceEntityPermissionsSql(int[] entityIds, string permissions, object[] 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(); + } + } +} \ 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 cd10d4e6a4..0acad10383 100644 --- a/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs @@ -17,7 +17,7 @@ namespace Umbraco.Core.Persistence.Repositories /// /// Represents the UserRepository for doing CRUD operations for /// - internal class UserRepository : PetaPocoRepositoryBase, IUserRepository + internal class UserRepository : PermissionRepository, IUserRepository { private readonly IUserTypeRepository _userTypeRepository; @@ -122,9 +122,12 @@ namespace Umbraco.Core.Persistence.Repositories } protected override IEnumerable GetDeleteClauses() - { + { var list = new List { + "DELETE FROM umbracoUser2NodePermission WHERE userId = @Id", + "DELETE FROM umbracoUser2NodeNotify WHERE userId = @Id", + "DELETE FROM umbracoUserLogins WHERE userId = @Id", "DELETE FROM umbracoUser2app WHERE " + SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName("user") + "=@Id", "DELETE FROM umbracoUser WHERE id = @Id" }; diff --git a/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs b/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs index 3a9b5041eb..0ed84582fa 100644 --- a/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs +++ b/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs @@ -8,7 +8,7 @@ using Umbraco.Core.Persistence.UnitOfWork; namespace Umbraco.Core.Persistence.Repositories { - internal abstract class VersionableRepositoryBase : PetaPocoRepositoryBase + internal abstract class VersionableRepositoryBase : PermissionRepository where TEntity : class, IAggregateRoot { protected VersionableRepositoryBase(IDatabaseUnitOfWork work) : base(work) diff --git a/src/Umbraco.Core/Persistence/UmbracoDatabase.cs b/src/Umbraco.Core/Persistence/UmbracoDatabase.cs index e69ef4cca2..522e0b4173 100644 --- a/src/Umbraco.Core/Persistence/UmbracoDatabase.cs +++ b/src/Umbraco.Core/Persistence/UmbracoDatabase.cs @@ -1,6 +1,8 @@ using System; +using System.Collections.Generic; using System.Data; using System.Data.Common; +using System.Linq; using StackExchange.Profiling; using Umbraco.Core.Logging; @@ -46,8 +48,7 @@ namespace Umbraco.Core.Persistence // wrap the connection with a profiling connection that tracks timings return new StackExchange.Profiling.Data.ProfiledDbConnection(connection as DbConnection, MiniProfiler.Current); } - - + public override void OnException(Exception x) { LogHelper.Info(x.StackTrace); diff --git a/src/Umbraco.Core/Services/UserService.cs b/src/Umbraco.Core/Services/UserService.cs index f7bbe244bb..e451d3aa05 100644 --- a/src/Umbraco.Core/Services/UserService.cs +++ b/src/Umbraco.Core/Services/UserService.cs @@ -164,7 +164,7 @@ namespace Umbraco.Core.Services Language = Umbraco.Core.Configuration.GlobalSettings.DefaultUILanguage, Name = name, Password = password, - Permissions = userType.Permissions, + DefaultPermissions = userType.Permissions, Username = login, StartContentId = -1, StartMediaId = -1, diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj index 9c97c3d453..ccc361e3f7 100644 --- a/src/Umbraco.Core/Umbraco.Core.csproj +++ b/src/Umbraco.Core/Umbraco.Core.csproj @@ -491,6 +491,7 @@ + diff --git a/src/Umbraco.Tests/Persistence/PetaPocoExtensionsTest.cs b/src/Umbraco.Tests/Persistence/PetaPocoExtensionsTest.cs new file mode 100644 index 0000000000..1cf6aff7b0 --- /dev/null +++ b/src/Umbraco.Tests/Persistence/PetaPocoExtensionsTest.cs @@ -0,0 +1,85 @@ +using System; +using System.Collections.Generic; +using NUnit.Framework; +using Umbraco.Core; +using Umbraco.Core.Models.Rdbms; +using Umbraco.Core.Persistence; +using Umbraco.Tests.TestHelpers; + +namespace Umbraco.Tests.Persistence +{ + [TestFixture] + public class PetaPocoExtensionsTest : BaseDatabaseFactoryTest + { + [SetUp] + public override void Initialize() + { + base.Initialize(); + } + + [TearDown] + public override void TearDown() + { + base.TearDown(); + } + + [Test] + public void Can_Bulk_Insert() + { + // Arrange + var db = DatabaseContext.Database; + + var servers = new List(); + for (var i = 0; i < 1000; i++) + { + servers.Add(new ServerRegistrationDto + { + Address = "address" + i, + ComputerName = "computer" + i, + DateRegistered = DateTime.Now, + IsActive = true, + LastNotified = DateTime.Now + }); + } + + // Act + using (DisposableTimer.TraceDuration("starting insert", "finished insert")) + { + db.BulkInsertRecords(servers); + } + + // Assert + Assert.That(db.ExecuteScalar("SELECT COUNT(*) FROM umbracoServer"), Is.EqualTo(1000)); + } + + [Test] + public void Generate_Bulk_Import_Sql() + { + // Arrange + var db = DatabaseContext.Database; + + var servers = new List(); + for (var i = 0; i < 2; i++) + { + servers.Add(new ServerRegistrationDto + { + Address = "address" + i, + ComputerName = "computer" + i, + DateRegistered = DateTime.Now, + IsActive = true, + LastNotified = DateTime.Now + }); + } + db.OpenSharedConnection(); + + // Act + string sql; + db.GenerateBulkInsertCommand(servers, db.Connection, out sql); + db.CloseSharedConnection(); + + // Assert + Assert.That(sql, + Is.EqualTo("INSERT INTO [umbracoServer] ([umbracoServer].[address], [umbracoServer].[computerName], [umbracoServer].[registeredDate], [umbracoServer].[lastNotifiedDate], [umbracoServer].[isActive]) VALUES (@0,@1,@2,@3,@4), (@5,@6,@7,@8,@9)")); + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Tests/Persistence/Querying/PetaPocoSqlTests.cs b/src/Umbraco.Tests/Persistence/Querying/PetaPocoSqlTests.cs index 4c71c072c7..3ee82a820e 100644 --- a/src/Umbraco.Tests/Persistence/Querying/PetaPocoSqlTests.cs +++ b/src/Umbraco.Tests/Persistence/Querying/PetaPocoSqlTests.cs @@ -1,7 +1,10 @@ using System; using NUnit.Framework; +using Umbraco.Core.Models; +using Umbraco.Core.Models.Membership; using Umbraco.Core.Models.Rdbms; using Umbraco.Core.Persistence; +using Umbraco.Core.Persistence.Repositories; using Umbraco.Tests.TestHelpers; namespace Umbraco.Tests.Persistence.Querying @@ -9,6 +12,26 @@ namespace Umbraco.Tests.Persistence.Querying [TestFixture] public class PetaPocoSqlTests : BaseUsingSqlCeSyntax { + [Test] + public void Generate_Replace_Entity_Permissions_Test() + { + // Act + var sql = PermissionRepository.GenerateReplaceEntityPermissionsSql(123, "abcd", new object[] {10, 11, 12}); + + // Assert + Assert.AreEqual(@"SET [permission]='abcd' 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}, "abcd", new object[] {10, 11, 12}); + + // Assert + Assert.AreEqual(@"SET [permission]='abcd' 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/Persistence/Repositories/ContentRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs index b7717c6a23..0fb31e831c 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs @@ -1,8 +1,10 @@ using System; +using System.Collections.Generic; using System.Linq; using NUnit.Framework; using Umbraco.Core; using Umbraco.Core.Models; +using Umbraco.Core.Models.Rdbms; using Umbraco.Core.Persistence; using Umbraco.Core.Persistence.Mappers; using Umbraco.Core.Persistence.Querying; @@ -32,6 +34,42 @@ namespace Umbraco.Tests.Persistence.Repositories base.TearDown(); } + [Test] + public void Ensures_Permissions_Are_Set_If_Parent_Entity_Permissions_Exist() + { + // Arrange + var provider = new PetaPocoUnitOfWorkProvider(); + var unitOfWork = provider.GetUnitOfWork(); + var contentTypeRepository = RepositoryResolver.Current.ResolveByType(unitOfWork); + var repository = (ContentRepository)RepositoryResolver.Current.ResolveByType(unitOfWork); + + var contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage", "Textpage"); + contentType.AllowedContentTypes = new List + { + new ContentTypeSort + { + Alias = contentType.Alias, + Id = new Lazy(() => contentType.Id), + SortOrder = 0 + } + }; + var parentPage = MockedContent.CreateSimpleContent(contentType); + contentTypeRepository.AddOrUpdate(contentType); + repository.AddOrUpdate(parentPage); + unitOfWork.Commit(); + + // Act + repository.AssignEntityPermissions(parentPage, "ABCD", new object[] {0}); + var childPage = MockedContent.CreateSimpleContent(contentType, "child", parentPage); + repository.AddOrUpdate(childPage); + unitOfWork.Commit(); + + // Assert + var permissions = repository.GetPermissionsForEntity(childPage.Id); + Assert.AreEqual(1, permissions.Count()); + Assert.AreEqual("ABCD", permissions.Single().Permission); + } + [Test] public void Can_Instantiate_Repository() { diff --git a/src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs index 76d21e1d56..a341a5cc74 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs @@ -115,7 +115,7 @@ namespace Umbraco.Tests.Persistence.Repositories var resolved = repository.Get((int)user.Id); resolved.Name = "New Name"; - resolved.Permissions = "ZYX"; + resolved.DefaultPermissions = "ZYX"; resolved.Language = "fr"; resolved.IsApproved = false; resolved.Password = "new"; @@ -134,7 +134,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Assert Assert.That(updatedItem.Id, Is.EqualTo(resolved.Id)); Assert.That(updatedItem.Name, Is.EqualTo(resolved.Name)); - Assert.That(updatedItem.Permissions, Is.EqualTo(resolved.Permissions)); + Assert.That(updatedItem.DefaultPermissions, Is.EqualTo(resolved.DefaultPermissions)); Assert.That(updatedItem.Language, Is.EqualTo(resolved.Language)); Assert.That(updatedItem.IsApproved, Is.EqualTo(resolved.IsApproved)); Assert.That(updatedItem.Password, Is.EqualTo(resolved.Password)); @@ -173,6 +173,32 @@ namespace Umbraco.Tests.Persistence.Repositories Assert.That(resolved, Is.Null); } + //[Test] + //public void Can_Perform_Delete_On_UserRepository_With_Permissions_Assigned() + //{ + // // Arrange + // var provider = new PetaPocoUnitOfWorkProvider(); + // var unitOfWork = provider.GetUnitOfWork(); + // var repository = RepositoryResolver.Current.ResolveByType(unitOfWork); + + // var user = MockedUser.CreateUser(CreateAndCommitUserType()); + // //repository.AssignPermissions() + + // // Act + // repository.AddOrUpdate(user); + // unitOfWork.Commit(); + // var id = user.Id; + + // var repository2 = RepositoryResolver.Current.ResolveByType(unitOfWork); + // repository2.Delete(user); + // unitOfWork.Commit(); + + // var resolved = repository2.Get((int)id); + + // // Assert + // Assert.That(resolved, Is.Null); + //} + [Test] public void Can_Perform_Get_On_UserRepository() { @@ -190,7 +216,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Assert AssertPropertyValues(updatedItem, user); } - + [Test] public void Can_Perform_GetByQuery_On_UserRepository() { @@ -405,7 +431,7 @@ namespace Umbraco.Tests.Persistence.Repositories { Assert.That(updatedItem.Id, Is.EqualTo(originalUser.Id)); Assert.That(updatedItem.Name, Is.EqualTo(originalUser.Name)); - Assert.That(updatedItem.Permissions, Is.EqualTo(originalUser.Permissions)); + Assert.That(updatedItem.DefaultPermissions, Is.EqualTo(originalUser.DefaultPermissions)); Assert.That(updatedItem.Language, Is.EqualTo(originalUser.Language)); Assert.That(updatedItem.IsApproved, Is.EqualTo(originalUser.IsApproved)); Assert.That(updatedItem.Password, Is.EqualTo(originalUser.Password)); diff --git a/src/Umbraco.Tests/Services/UserServiceTests.cs b/src/Umbraco.Tests/Services/UserServiceTests.cs index 6da5002436..b8cc7f6225 100644 --- a/src/Umbraco.Tests/Services/UserServiceTests.cs +++ b/src/Umbraco.Tests/Services/UserServiceTests.cs @@ -39,7 +39,7 @@ namespace Umbraco.Tests.Services Assert.That(membershipUser.HasIdentity, Is.True); IUser user = membershipUser as User; Assert.That(user, Is.Not.Null); - Assert.That(user.Permissions, Is.EqualTo(userType.Permissions)); + Assert.That(user.DefaultPermissions, Is.EqualTo(userType.Permissions)); } [Test] @@ -63,7 +63,7 @@ namespace Umbraco.Tests.Services Assert.That(membershipUser.Password, Is.EqualTo(encodedPassword)); IUser user = membershipUser as User; Assert.That(user, Is.Not.Null); - Assert.That(user.Permissions, Is.EqualTo(userType.Permissions)); + Assert.That(user.DefaultPermissions, Is.EqualTo(userType.Permissions)); } [Test] @@ -140,7 +140,7 @@ namespace Umbraco.Tests.Services Assert.IsNotNull(updatedItem); Assert.That(updatedItem.Id, Is.EqualTo(originalUser.Id)); Assert.That(updatedItem.Name, Is.EqualTo(originalUser.Name)); - Assert.That(updatedItem.Permissions, Is.EqualTo(originalUser.Permissions)); + Assert.That(updatedItem.DefaultPermissions, Is.EqualTo(originalUser.DefaultPermissions)); Assert.That(updatedItem.Language, Is.EqualTo(originalUser.Language)); Assert.That(updatedItem.IsApproved, Is.EqualTo(originalUser.IsApproved)); Assert.That(updatedItem.Password, Is.EqualTo(originalUser.Password)); diff --git a/src/Umbraco.Tests/TestHelpers/Entities/MockedUser.cs b/src/Umbraco.Tests/TestHelpers/Entities/MockedUser.cs index 19e0148383..7df112515d 100644 --- a/src/Umbraco.Tests/TestHelpers/Entities/MockedUser.cs +++ b/src/Umbraco.Tests/TestHelpers/Entities/MockedUser.cs @@ -19,7 +19,7 @@ namespace Umbraco.Tests.TestHelpers.Entities Name = "TestUser" + suffix, Password = "testing", NoConsole = false, - Permissions = "ABC", + DefaultPermissions = "ABC", StartContentId = -1, StartMediaId = -1, DefaultToLiveEditing = false, diff --git a/src/Umbraco.Tests/Umbraco.Tests.csproj b/src/Umbraco.Tests/Umbraco.Tests.csproj index e4d21a8039..37b33cf460 100644 --- a/src/Umbraco.Tests/Umbraco.Tests.csproj +++ b/src/Umbraco.Tests/Umbraco.Tests.csproj @@ -185,6 +185,7 @@ + diff --git a/src/umbraco.businesslogic/User.cs b/src/umbraco.businesslogic/User.cs index ae5c0202ab..3ee8608da0 100644 --- a/src/umbraco.businesslogic/User.cs +++ b/src/umbraco.businesslogic/User.cs @@ -1,6 +1,7 @@ using System; using System.Collections; using Umbraco.Core; +using Umbraco.Core.Cache; using Umbraco.Core.Logging; using umbraco.DataLayer; using System.Collections.Generic; @@ -667,7 +668,7 @@ namespace umbraco.BusinessLogic { if (!_isInitialized) setupUser(_id); - string cruds = UserType.DefaultPermissions; + string defaultPermissions = UserType.DefaultPermissions; if (!_crudsInitialized) initCruds(); @@ -681,16 +682,16 @@ namespace umbraco.BusinessLogic } // exception to everything. If default cruds is empty and we're on root node; allow browse of root node - if (String.IsNullOrEmpty(cruds) && Path == "-1") - cruds = "F"; + if (String.IsNullOrEmpty(defaultPermissions) && Path == "-1") + defaultPermissions = "F"; // else return default user type cruds - return cruds; + return defaultPermissions; } /// /// Initializes the user node permissions - /// + /// public void initCruds() { if (!_isInitialized) @@ -904,7 +905,7 @@ namespace umbraco.BusinessLogic public void FlushFromCache() { OnFlushingFromCache(EventArgs.Empty); - ApplicationContext.Current.ApplicationCache.ClearCacheItem(string.Format("UmbracoUser{0}", Id.ToString())); + ApplicationContext.Current.ApplicationCache.ClearCacheItem(string.Format("{0}{1}", CacheKeys.UserCacheKey, Id.ToString())); } /// @@ -915,7 +916,7 @@ namespace umbraco.BusinessLogic public static User GetUser(int id) { return ApplicationContext.Current.ApplicationCache.GetCacheItem( - string.Format("UmbracoUser{0}", id.ToString()), () => + string.Format("{0}{1}", CacheKeys.UserCacheKey, id.ToString()), () => { try {