From 7e20e81cc8de8a69ece510f3681755e1ed53939c Mon Sep 17 00:00:00 2001 From: Shannon Date: Fri, 21 Dec 2018 13:15:46 +1100 Subject: [PATCH] Fixes EntityRepository and EntityService to perform order by operations correctly --- .../Repositories/IEntityRepository.cs | 3 +- .../Implement/EntityRepository.cs | 68 +++++++++++----- src/Umbraco.Core/Services/IEntityService.cs | 11 +-- .../Services/Implement/EntityService.cs | 20 ++--- .../Services/EntityServiceTests.cs | 80 ++++++++++++++++++- src/Umbraco.Web/Editors/ContentController.cs | 2 +- src/Umbraco.Web/Editors/EntityController.cs | 17 +++- .../Trees/ContentTypeTreeController.cs | 4 +- .../Trees/DataTypeTreeController.cs | 4 +- .../Trees/MediaTypeTreeController.cs | 5 +- .../Trees/TemplatesTreeController.cs | 3 +- 11 files changed, 164 insertions(+), 53 deletions(-) diff --git a/src/Umbraco.Core/Persistence/Repositories/IEntityRepository.cs b/src/Umbraco.Core/Persistence/Repositories/IEntityRepository.cs index b53b117a1a..69f6ef4c5f 100644 --- a/src/Umbraco.Core/Persistence/Repositories/IEntityRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/IEntityRepository.cs @@ -4,6 +4,7 @@ using Umbraco.Core.Models; using Umbraco.Core.Models.Entities; using Umbraco.Core.Persistence.DatabaseModelDefinitions; using Umbraco.Core.Persistence.Querying; +using Umbraco.Core.Services; namespace Umbraco.Core.Persistence.Repositories { @@ -30,6 +31,6 @@ namespace Umbraco.Core.Persistence.Repositories bool Exists(Guid key); IEnumerable GetPagedResultsByQuery(IQuery query, Guid objectType, long pageIndex, int pageSize, out long totalRecords, - string orderBy, Direction orderDirection, IQuery filter = null); + IQuery filter, Ordering ordering); } } diff --git a/src/Umbraco.Core/Persistence/Repositories/Implement/EntityRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Implement/EntityRepository.cs index 8d6f67e9db..2be27deb0a 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Implement/EntityRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Implement/EntityRepository.cs @@ -10,6 +10,7 @@ using Umbraco.Core.Persistence.Querying; using Umbraco.Core.Scoping; using static Umbraco.Core.Persistence.NPocoSqlExtensions.Statics; using Umbraco.Core.Persistence.SqlSyntax; +using Umbraco.Core.Services; namespace Umbraco.Core.Persistence.Repositories.Implement { @@ -25,12 +26,10 @@ namespace Umbraco.Core.Persistence.Repositories.Implement internal class EntityRepository : IEntityRepository { private readonly IScopeAccessor _scopeAccessor; - private readonly ILanguageRepository _langRepository; - public EntityRepository(IScopeAccessor scopeAccessor, ILanguageRepository langRepository) + public EntityRepository(IScopeAccessor scopeAccessor) { _scopeAccessor = scopeAccessor; - _langRepository = langRepository; } protected IUmbracoDatabase Database => _scopeAccessor.AmbientScope.Database; @@ -41,7 +40,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement // get a page of entities public IEnumerable GetPagedResultsByQuery(IQuery query, Guid objectType, long pageIndex, int pageSize, out long totalRecords, - string orderBy, Direction orderDirection, IQuery filter = null) + IQuery filter, Ordering ordering) { var isContent = objectType == Constants.ObjectTypes.Document || objectType == Constants.ObjectTypes.DocumentBlueprint; var isMedia = objectType == Constants.ObjectTypes.Media; @@ -53,11 +52,21 @@ namespace Umbraco.Core.Persistence.Repositories.Implement x.Where(filterClause.Item1, filterClause.Item2); }, objectType); + ordering = ordering ?? Ordering.ByDefault(); + var translator = new SqlTranslator(sql, query); sql = translator.Translate(); - sql = AddGroupBy(isContent, isMedia, sql); + sql = AddGroupBy(isContent, isMedia, sql, ordering.IsEmpty); + + if (!ordering.IsEmpty) + { + // apply ordering + ApplyOrdering(ref sql, ordering); + } + //fixme - we should be able to do sql = sql.OrderBy(x => Alias(x.NodeId, "NodeId")); but we can't because the OrderBy extension don't support Alias currently - sql = sql.OrderBy("NodeId"); + //no matter what we always must have node id ordered at the end + sql = ordering.Direction == Direction.Ascending ? sql.OrderBy("NodeId") : sql.OrderByDescending("NodeId"); var page = Database.Page(pageIndex + 1, pageSize, sql); var dtos = page.Items; @@ -81,6 +90,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement return dto == null ? null : BuildEntity(false, false, dto); } + private IEntitySlim GetEntity(Sql sql, bool isContent, bool isMedia) { //isContent is going to return a 1:M result now with the variants so we need to do different things @@ -200,7 +210,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement var sqlClause = GetBase(false, false, null); var translator = new SqlTranslator(sqlClause, query); var sql = translator.Translate(); - sql = AddGroupBy(false, false, sql); + sql = AddGroupBy(false, false, sql, true); var dtos = Database.Fetch(sql); return dtos.Select(x => BuildEntity(false, false, x)).ToList(); } @@ -214,7 +224,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement var translator = new SqlTranslator(sql, query); sql = translator.Translate(); - sql = AddGroupBy(isContent, isMedia, sql); + sql = AddGroupBy(isContent, isMedia, sql, true); return GetEntities(sql, isContent, isMedia, true); } @@ -229,7 +239,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement var translator = new SqlTranslator(sql, query); sql = translator.Translate(); - sql = AddGroupBy(isContent, isMedia, sql); + sql = AddGroupBy(isContent, isMedia, sql, true); return GetEntities(sql, isContent, isMedia, false); } @@ -361,21 +371,21 @@ namespace Umbraco.Core.Persistence.Repositories.Implement protected Sql GetFullSqlForEntityType(bool isContent, bool isMedia, Guid objectType, Guid uniqueId) { var sql = GetBaseWhere(isContent, isMedia, false, objectType, uniqueId); - return AddGroupBy(isContent, isMedia, sql); + return AddGroupBy(isContent, isMedia, sql, true); } // gets the full sql for a given object type and a given node id protected Sql GetFullSqlForEntityType(bool isContent, bool isMedia, Guid objectType, int nodeId) { var sql = GetBaseWhere(isContent, isMedia, false, objectType, nodeId); - return AddGroupBy(isContent, isMedia, sql); + return AddGroupBy(isContent, isMedia, sql, true); } // gets the full sql for a given object type, with a given filter protected Sql GetFullSqlForEntityType(bool isContent, bool isMedia, Guid objectType, Action> filter) { var sql = GetBaseWhere(isContent, isMedia, false, filter, objectType); - return AddGroupBy(isContent, isMedia, sql); + return AddGroupBy(isContent, isMedia, sql, true); } private Sql GetPropertyData(int versionId) @@ -401,7 +411,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement // gets the base SELECT + FROM [+ filter] sql // always from the 'current' content version - protected virtual Sql GetBase(bool isContent, bool isMedia, Action> filter, bool isCount = false) + protected Sql GetBase(bool isContent, bool isMedia, Action> filter, bool isCount = false) { var sql = Sql(); @@ -460,7 +470,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement // gets the base SELECT + FROM [+ filter] + WHERE sql // for a given object type, with a given filter - protected virtual Sql GetBaseWhere(bool isContent, bool isMedia, bool isCount, Action> filter, Guid objectType) + protected Sql GetBaseWhere(bool isContent, bool isMedia, bool isCount, Action> filter, Guid objectType) { return GetBase(isContent, isMedia, filter, isCount) .Where(x => x.NodeObjectType == objectType); @@ -468,25 +478,25 @@ namespace Umbraco.Core.Persistence.Repositories.Implement // gets the base SELECT + FROM + WHERE sql // for a given node id - protected virtual Sql GetBaseWhere(bool isContent, bool isMedia, bool isCount, int id) + protected Sql GetBaseWhere(bool isContent, bool isMedia, bool isCount, int id) { var sql = GetBase(isContent, isMedia, null, isCount) .Where(x => x.NodeId == id); - return AddGroupBy(isContent, isMedia, sql); + return AddGroupBy(isContent, isMedia, sql, true); } // gets the base SELECT + FROM + WHERE sql // for a given unique id - protected virtual Sql GetBaseWhere(bool isContent, bool isMedia, bool isCount, Guid uniqueId) + protected Sql GetBaseWhere(bool isContent, bool isMedia, bool isCount, Guid uniqueId) { var sql = GetBase(isContent, isMedia, null, isCount) .Where(x => x.UniqueId == uniqueId); - return AddGroupBy(isContent, isMedia, sql); + return AddGroupBy(isContent, isMedia, sql, true); } // gets the base SELECT + FROM + WHERE sql // for a given object type and node id - protected virtual Sql GetBaseWhere(bool isContent, bool isMedia, bool isCount, Guid objectType, int nodeId) + protected Sql GetBaseWhere(bool isContent, bool isMedia, bool isCount, Guid objectType, int nodeId) { return GetBase(isContent, isMedia, null, isCount) .Where(x => x.NodeId == nodeId && x.NodeObjectType == objectType); @@ -494,7 +504,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement // gets the base SELECT + FROM + WHERE sql // for a given object type and unique id - protected virtual Sql GetBaseWhere(bool isContent, bool isMedia, bool isCount, Guid objectType, Guid uniqueId) + protected Sql GetBaseWhere(bool isContent, bool isMedia, bool isCount, Guid objectType, Guid uniqueId) { return GetBase(isContent, isMedia, null, isCount) .Where(x => x.UniqueId == uniqueId && x.NodeObjectType == objectType); @@ -502,7 +512,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement // gets the GROUP BY / ORDER BY sql // required in order to count children - protected virtual Sql AddGroupBy(bool isContent, bool isMedia, Sql sql, bool sort = true) + protected Sql AddGroupBy(bool isContent, bool isMedia, Sql sql, bool defaultSort) { sql .GroupBy(x => x.NodeId, x => x.Trashed, x => x.ParentId, x => x.UserId, x => x.Level, x => x.Path) @@ -520,12 +530,26 @@ namespace Umbraco.Core.Persistence.Repositories.Implement .AndBy(x => x.Id) .AndBy(x => x.Alias, x => x.Icon, x => x.Thumbnail, x => x.IsContainer, x => x.Variations); - if (sort) + if (defaultSort) sql.OrderBy(x => x.SortOrder); return sql; } + private void ApplyOrdering(ref Sql sql, Ordering ordering) + { + if (sql == null) throw new ArgumentNullException(nameof(sql)); + if (ordering == null) throw new ArgumentNullException(nameof(ordering)); + + //fixme - although this works for name, it probably doesn't work for others without an alias of some sort + var orderBy = ordering.OrderBy; + + if (ordering.Direction == Direction.Ascending) + sql.OrderBy(orderBy); + else + sql.OrderByDescending(orderBy); + } + #endregion #region Classes diff --git a/src/Umbraco.Core/Services/IEntityService.cs b/src/Umbraco.Core/Services/IEntityService.cs index 926afcf0a9..3937d5bf40 100644 --- a/src/Umbraco.Core/Services/IEntityService.cs +++ b/src/Umbraco.Core/Services/IEntityService.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using Umbraco.Core.Models; using Umbraco.Core.Models.Entities; using Umbraco.Core.Persistence.DatabaseModelDefinitions; +using Umbraco.Core.Persistence.Querying; namespace Umbraco.Core.Services { @@ -227,25 +228,25 @@ namespace Umbraco.Core.Services /// Gets children of an entity. /// IEnumerable GetPagedChildren(int id, UmbracoObjectTypes objectType, long pageIndex, int pageSize, out long totalRecords, - string orderBy = "SortOrder", Direction orderDirection = Direction.Ascending, string filter = ""); + IQuery filter = null, Ordering ordering = null); /// /// Gets descendants of an entity. /// IEnumerable GetPagedDescendants(int id, UmbracoObjectTypes objectType, long pageIndex, int pageSize, out long totalRecords, - string orderBy = "path", Direction orderDirection = Direction.Ascending, string filter = ""); + IQuery filter = null, Ordering ordering = null); /// /// Gets descendants of entities. /// IEnumerable GetPagedDescendants(IEnumerable ids, UmbracoObjectTypes objectType, long pageIndex, int pageSize, out long totalRecords, - string orderBy = "path", Direction orderDirection = Direction.Ascending, string filter = ""); + IQuery filter = null, Ordering ordering = null); /// - /// Gets descendants of root. + /// Gets descendants of root. fixme: Do we really need this? why not just pass in -1 /// IEnumerable GetPagedDescendants(UmbracoObjectTypes objectType, long pageIndex, int pageSize, out long totalRecords, - string orderBy = "path", Direction orderDirection = Direction.Ascending, string filter = "", bool includeTrashed = true); + IQuery filter = null, Ordering ordering = null, bool includeTrashed = true); /// /// Gets the object type of an entity. diff --git a/src/Umbraco.Core/Services/Implement/EntityService.cs b/src/Umbraco.Core/Services/Implement/EntityService.cs index 45c229214a..4a3db29940 100644 --- a/src/Umbraco.Core/Services/Implement/EntityService.cs +++ b/src/Umbraco.Core/Services/Implement/EntityService.cs @@ -415,20 +415,19 @@ namespace Umbraco.Core.Services.Implement /// public IEnumerable GetPagedChildren(int id, UmbracoObjectTypes objectType, long pageIndex, int pageSize, out long totalRecords, - string orderBy = "SortOrder", Direction orderDirection = Direction.Ascending, string filter = "") + IQuery filter = null, Ordering ordering = null) { using (ScopeProvider.CreateScope(autoComplete: true)) { var query = Query().Where(x => x.ParentId == id && x.Trashed == false); - var filterQuery = string.IsNullOrWhiteSpace(filter) ? null : Query().Where(x => x.Name.Contains(filter)); - return _entityRepository.GetPagedResultsByQuery(query, objectType.GetGuid(), pageIndex, pageSize, out totalRecords, orderBy, orderDirection, filterQuery); + return _entityRepository.GetPagedResultsByQuery(query, objectType.GetGuid(), pageIndex, pageSize, out totalRecords, filter, ordering); } } /// public IEnumerable GetPagedDescendants(int id, UmbracoObjectTypes objectType, long pageIndex, int pageSize, out long totalRecords, - string orderBy = "path", Direction orderDirection = Direction.Ascending, string filter = "") + IQuery filter = null, Ordering ordering = null) { using (ScopeProvider.CreateScope(autoComplete: true)) { @@ -448,14 +447,13 @@ namespace Umbraco.Core.Services.Implement query.Where(x => x.Path.SqlStartsWith(path + ",", TextColumnType.NVarchar)); } - var filterQuery = string.IsNullOrWhiteSpace(filter) ? null : Query().Where(x => x.Name.Contains(filter)); - return _entityRepository.GetPagedResultsByQuery(query, objectTypeGuid, pageIndex, pageSize, out totalRecords, orderBy, orderDirection, filterQuery); + return _entityRepository.GetPagedResultsByQuery(query, objectTypeGuid, pageIndex, pageSize, out totalRecords, filter, ordering); } } /// public IEnumerable GetPagedDescendants(IEnumerable ids, UmbracoObjectTypes objectType, long pageIndex, int pageSize, out long totalRecords, - string orderBy = "path", Direction orderDirection = Direction.Ascending, string filter = "") + IQuery filter = null, Ordering ordering = null) { totalRecords = 0; @@ -492,14 +490,13 @@ namespace Umbraco.Core.Services.Implement query.WhereAny(clauses); } - var filterQuery = string.IsNullOrWhiteSpace(filter) ? null : Query().Where(x => x.Name.Contains(filter)); - return _entityRepository.GetPagedResultsByQuery(query, objectTypeGuid, pageIndex, pageSize, out totalRecords, orderBy, orderDirection, filterQuery); + return _entityRepository.GetPagedResultsByQuery(query, objectTypeGuid, pageIndex, pageSize, out totalRecords, filter, ordering); } } /// public IEnumerable GetPagedDescendants(UmbracoObjectTypes objectType, long pageIndex, int pageSize, out long totalRecords, - string orderBy = "path", Direction orderDirection = Direction.Ascending, string filter = "", bool includeTrashed = true) + IQuery filter = null, Ordering ordering = null, bool includeTrashed = true) { using (ScopeProvider.CreateScope(autoComplete: true)) { @@ -507,8 +504,7 @@ namespace Umbraco.Core.Services.Implement if (includeTrashed == false) query.Where(x => x.Trashed == false); - var filterQuery = string.IsNullOrWhiteSpace(filter) ? null : Query().Where(x => x.Name.Contains(filter)); - return _entityRepository.GetPagedResultsByQuery(query, objectType.GetGuid(), pageIndex, pageSize, out totalRecords, orderBy, orderDirection, filterQuery); + return _entityRepository.GetPagedResultsByQuery(query, objectType.GetGuid(), pageIndex, pageSize, out totalRecords, filter, ordering); } } diff --git a/src/Umbraco.Tests/Services/EntityServiceTests.cs b/src/Umbraco.Tests/Services/EntityServiceTests.cs index 1db653f4ab..2425f8b74a 100644 --- a/src/Umbraco.Tests/Services/EntityServiceTests.cs +++ b/src/Umbraco.Tests/Services/EntityServiceTests.cs @@ -6,6 +6,7 @@ using NUnit.Framework; using Umbraco.Core; using Umbraco.Core.Models; using Umbraco.Core.Models.Entities; +using Umbraco.Core.Persistence.DatabaseModelDefinitions; using Umbraco.Core.Services; using Umbraco.Tests.TestHelpers; using Umbraco.Tests.TestHelpers.Entities; @@ -37,6 +38,53 @@ namespace Umbraco.Tests.Services } } + [Test] + public void EntityService_Can_Get_Paged_Descendants_Ordering_Path() + { + + var contentType = ServiceContext.ContentTypeService.Get("umbTextpage"); + + var root = MockedContent.CreateSimpleContent(contentType); + ServiceContext.ContentService.Save(root); + var rootId = root.Id; + var ids = new List(); + for (int i = 0; i < 10; i++) + { + var c1 = MockedContent.CreateSimpleContent(contentType, Guid.NewGuid().ToString(), root); + ServiceContext.ContentService.Save(c1); + ids.Add(c1.Id); + root = c1; // make a hierarchy + } + + var service = ServiceContext.EntityService; + + long total; + + var entities = service.GetPagedDescendants(rootId, UmbracoObjectTypes.Document, 0, 6, out total).ToArray(); + Assert.That(entities.Length, Is.EqualTo(6)); + Assert.That(total, Is.EqualTo(10)); + Assert.AreEqual(ids[0], entities[0].Id); + + entities = service.GetPagedDescendants(rootId, UmbracoObjectTypes.Document, 1, 6, out total).ToArray(); + Assert.That(entities.Length, Is.EqualTo(4)); + Assert.That(total, Is.EqualTo(10)); + Assert.AreEqual(ids[6], entities[0].Id); + + //Test ordering direction + + entities = service.GetPagedDescendants(rootId, UmbracoObjectTypes.Document, 0, 6, out total, + ordering: Ordering.By("Path", Direction.Descending)).ToArray(); + Assert.That(entities.Length, Is.EqualTo(6)); + Assert.That(total, Is.EqualTo(10)); + Assert.AreEqual(ids[ids.Count - 1], entities[0].Id); + + entities = service.GetPagedDescendants(rootId, UmbracoObjectTypes.Document, 1, 6, out total, + ordering: Ordering.By("Path", Direction.Descending)).ToArray(); + Assert.That(entities.Length, Is.EqualTo(4)); + Assert.That(total, Is.EqualTo(10)); + Assert.AreEqual(ids[ids.Count - 1 - 6], entities[0].Id); + } + [Test] public void EntityService_Can_Get_Paged_Content_Children() { @@ -45,21 +93,41 @@ namespace Umbraco.Tests.Services var root = MockedContent.CreateSimpleContent(contentType); ServiceContext.ContentService.Save(root); + var ids = new List(); for (int i = 0; i < 10; i++) { var c1 = MockedContent.CreateSimpleContent(contentType, Guid.NewGuid().ToString(), root); ServiceContext.ContentService.Save(c1); + ids.Add(c1.Id); } var service = ServiceContext.EntityService; long total; + var entities = service.GetPagedChildren(root.Id, UmbracoObjectTypes.Document, 0, 6, out total).ToArray(); Assert.That(entities.Length, Is.EqualTo(6)); Assert.That(total, Is.EqualTo(10)); + Assert.AreEqual(ids[0], entities[0].Id); + entities = service.GetPagedChildren(root.Id, UmbracoObjectTypes.Document, 1, 6, out total).ToArray(); Assert.That(entities.Length, Is.EqualTo(4)); Assert.That(total, Is.EqualTo(10)); + Assert.AreEqual(ids[6], entities[0].Id); + + //Test ordering direction + + entities = service.GetPagedChildren(root.Id, UmbracoObjectTypes.Document, 0, 6, out total, + ordering: Ordering.By("SortOrder", Direction.Descending)).ToArray(); + Assert.That(entities.Length, Is.EqualTo(6)); + Assert.That(total, Is.EqualTo(10)); + Assert.AreEqual(ids[ids.Count - 1], entities[0].Id); + + entities = service.GetPagedChildren(root.Id, UmbracoObjectTypes.Document, 1, 6, out total, + ordering: Ordering.By("SortOrder", Direction.Descending)).ToArray(); + Assert.That(entities.Length, Is.EqualTo(4)); + Assert.That(total, Is.EqualTo(10)); + Assert.AreEqual(ids[ids.Count - 1 - 6], entities[0].Id); } [Test] @@ -206,10 +274,12 @@ namespace Umbraco.Tests.Services var service = ServiceContext.EntityService; long total; - var entities = service.GetPagedDescendants(root.Id, UmbracoObjectTypes.Document, 0, 10, out total, filter: "ssss").ToArray(); + var entities = service.GetPagedDescendants(root.Id, UmbracoObjectTypes.Document, 0, 10, out total, + filter: SqlContext.Query().Where(x => x.Name.Contains("ssss"))).ToArray(); Assert.That(entities.Length, Is.EqualTo(10)); Assert.That(total, Is.EqualTo(10)); - entities = service.GetPagedDescendants(root.Id, UmbracoObjectTypes.Document, 0, 50, out total, filter: "tttt").ToArray(); + entities = service.GetPagedDescendants(root.Id, UmbracoObjectTypes.Document, 0, 50, out total, + filter: SqlContext.Query().Where(x => x.Name.Contains("tttt"))).ToArray(); Assert.That(entities.Length, Is.EqualTo(50)); Assert.That(total, Is.EqualTo(50)); } @@ -389,10 +459,12 @@ namespace Umbraco.Tests.Services var service = ServiceContext.EntityService; long total; - var entities = service.GetPagedDescendants(root.Id, UmbracoObjectTypes.Media, 0, 10, out total, filter: "ssss").ToArray(); + var entities = service.GetPagedDescendants(root.Id, UmbracoObjectTypes.Media, 0, 10, out total, + filter: SqlContext.Query().Where(x => x.Name.Contains("ssss"))).ToArray(); Assert.That(entities.Length, Is.EqualTo(10)); Assert.That(total, Is.EqualTo(10)); - entities = service.GetPagedDescendants(root.Id, UmbracoObjectTypes.Media, 0, 50, out total, filter: "tttt").ToArray(); + entities = service.GetPagedDescendants(root.Id, UmbracoObjectTypes.Media, 0, 50, out total, + filter: SqlContext.Query().Where(x => x.Name.Contains("tttt"))).ToArray(); Assert.That(entities.Length, Is.EqualTo(50)); Assert.That(total, Is.EqualTo(50)); } diff --git a/src/Umbraco.Web/Editors/ContentController.cs b/src/Umbraco.Web/Editors/ContentController.cs index 8245a21019..2ec92c946e 100644 --- a/src/Umbraco.Web/Editors/ContentController.cs +++ b/src/Umbraco.Web/Editors/ContentController.cs @@ -1065,7 +1065,7 @@ namespace Umbraco.Web.Editors var descendants = Services.EntityService.GetPagedDescendants(contentItem.Id, UmbracoObjectTypes.Document, page++, pageSize, out total, //order by shallowest to deepest, this allows us to check permissions from top to bottom so we can exit //early if a permission higher up fails - "path", Direction.Ascending); + ordering: Ordering.By("path", Direction.Ascending)); foreach (var c in descendants) { diff --git a/src/Umbraco.Web/Editors/EntityController.cs b/src/Umbraco.Web/Editors/EntityController.cs index 3cecdbe8e5..5e73f4140e 100644 --- a/src/Umbraco.Web/Editors/EntityController.cs +++ b/src/Umbraco.Web/Editors/EntityController.cs @@ -17,6 +17,7 @@ using Umbraco.Core.Persistence.DatabaseModelDefinitions; using System.Web.Http.Controllers; using Examine; using Umbraco.Core.Models.Entities; +using Umbraco.Core.Services; using Umbraco.Core.Xml; using Umbraco.Web.Models.Mapping; using Umbraco.Web.Search; @@ -477,7 +478,9 @@ namespace Umbraco.Web.Editors var objectType = ConvertToObjectType(type); if (objectType.HasValue) { - var entities = Services.EntityService.GetPagedChildren(id, objectType.Value, pageNumber - 1, pageSize, out var totalRecords, orderBy, orderDirection, filter); + var entities = Services.EntityService.GetPagedChildren(id, objectType.Value, pageNumber - 1, pageSize, out var totalRecords, + SqlContext.Query().Where(x => x.Name.Contains(filter)), + Ordering.By(orderBy, orderDirection)); if (totalRecords == 0) { @@ -545,12 +548,18 @@ namespace Umbraco.Web.Editors } entities = aids == null || aids.Contains(Constants.System.Root) - ? Services.EntityService.GetPagedDescendants(objectType.Value, pageNumber - 1, pageSize, out totalRecords, orderBy, orderDirection, filter, includeTrashed: false) - : Services.EntityService.GetPagedDescendants(aids, objectType.Value, pageNumber - 1, pageSize, out totalRecords, orderBy, orderDirection, filter); + ? Services.EntityService.GetPagedDescendants(objectType.Value, pageNumber - 1, pageSize, out totalRecords, + SqlContext.Query().Where(x => x.Name.Contains(filter)), + Ordering.By(orderBy, orderDirection), includeTrashed: false) + : Services.EntityService.GetPagedDescendants(aids, objectType.Value, pageNumber - 1, pageSize, out totalRecords, + SqlContext.Query().Where(x => x.Name.Contains(filter)), + Ordering.By(orderBy, orderDirection)); } else { - entities = Services.EntityService.GetPagedDescendants(id, objectType.Value, pageNumber - 1, pageSize, out totalRecords, orderBy, orderDirection, filter); + entities = Services.EntityService.GetPagedDescendants(id, objectType.Value, pageNumber - 1, pageSize, out totalRecords, + SqlContext.Query().Where(x => x.Name.Contains(filter)), + Ordering.By(orderBy, orderDirection)); } if (totalRecords == 0) diff --git a/src/Umbraco.Web/Trees/ContentTypeTreeController.cs b/src/Umbraco.Web/Trees/ContentTypeTreeController.cs index 0ef3c073eb..a3d65aea5f 100644 --- a/src/Umbraco.Web/Trees/ContentTypeTreeController.cs +++ b/src/Umbraco.Web/Trees/ContentTypeTreeController.cs @@ -6,6 +6,7 @@ using System.Net.Http.Formatting; using Umbraco.Core; using Umbraco.Core.Configuration; using Umbraco.Core.Models; +using Umbraco.Core.Models.Entities; using Umbraco.Core.Services; using Umbraco.Web.Actions; @@ -144,7 +145,8 @@ namespace Umbraco.Web.Trees public IEnumerable Search(string query, int pageSize, long pageIndex, out long totalFound, string searchFrom = null) { - var results = Services.EntityService.GetPagedDescendants(UmbracoObjectTypes.DocumentType, pageIndex, pageSize, out totalFound, filter: query); + var results = Services.EntityService.GetPagedDescendants(UmbracoObjectTypes.DocumentType, pageIndex, pageSize, out totalFound, + filter: SqlContext.Query().Where(x => x.Name.Contains(query))); return Mapper.Map>(results); } } diff --git a/src/Umbraco.Web/Trees/DataTypeTreeController.cs b/src/Umbraco.Web/Trees/DataTypeTreeController.cs index 0970481357..b8e77f981d 100644 --- a/src/Umbraco.Web/Trees/DataTypeTreeController.cs +++ b/src/Umbraco.Web/Trees/DataTypeTreeController.cs @@ -5,6 +5,7 @@ using System.Net.Http.Formatting; using AutoMapper; using Umbraco.Core; using Umbraco.Core.Models; +using Umbraco.Core.Models.Entities; using Umbraco.Web.Models.Trees; using Umbraco.Web.Mvc; using Umbraco.Web.WebApi.Filters; @@ -144,7 +145,8 @@ namespace Umbraco.Web.Trees public IEnumerable Search(string query, int pageSize, long pageIndex, out long totalFound, string searchFrom = null) { - var results = Services.EntityService.GetPagedDescendants(UmbracoObjectTypes.DataType, pageIndex, pageSize, out totalFound, filter: query); + var results = Services.EntityService.GetPagedDescendants(UmbracoObjectTypes.DataType, pageIndex, pageSize, out totalFound, + filter: SqlContext.Query().Where(x => x.Name.Contains(query))); return Mapper.Map>(results); } } diff --git a/src/Umbraco.Web/Trees/MediaTypeTreeController.cs b/src/Umbraco.Web/Trees/MediaTypeTreeController.cs index 8b3ad5e8cd..bdcc2dc029 100644 --- a/src/Umbraco.Web/Trees/MediaTypeTreeController.cs +++ b/src/Umbraco.Web/Trees/MediaTypeTreeController.cs @@ -6,6 +6,8 @@ using AutoMapper; using Umbraco.Core; using Umbraco.Core.Configuration; using Umbraco.Core.Models; +using Umbraco.Core.Models.Entities; +using Umbraco.Core.Persistence.Querying; using Umbraco.Web.Models.Trees; using Umbraco.Web.WebApi.Filters; using Umbraco.Core.Services; @@ -135,7 +137,8 @@ namespace Umbraco.Web.Trees public IEnumerable Search(string query, int pageSize, long pageIndex, out long totalFound, string searchFrom = null) { - var results = Services.EntityService.GetPagedDescendants(UmbracoObjectTypes.MediaType, pageIndex, pageSize, out totalFound, filter: query); + var results = Services.EntityService.GetPagedDescendants(UmbracoObjectTypes.MediaType, pageIndex, pageSize, out totalFound, + filter: SqlContext.Query().Where(x => x.Name.Contains(query))); return Mapper.Map>(results); } } diff --git a/src/Umbraco.Web/Trees/TemplatesTreeController.cs b/src/Umbraco.Web/Trees/TemplatesTreeController.cs index 56f47695a0..fce51e2435 100644 --- a/src/Umbraco.Web/Trees/TemplatesTreeController.cs +++ b/src/Umbraco.Web/Trees/TemplatesTreeController.cs @@ -135,7 +135,8 @@ namespace Umbraco.Web.Trees public IEnumerable Search(string query, int pageSize, long pageIndex, out long totalFound, string searchFrom = null) { - var results = Services.EntityService.GetPagedDescendants(UmbracoObjectTypes.Template, pageIndex, pageSize, out totalFound, filter: query); + var results = Services.EntityService.GetPagedDescendants(UmbracoObjectTypes.Template, pageIndex, pageSize, out totalFound, + filter: SqlContext.Query().Where(x => x.Name.Contains(query))); return Mapper.Map>(results); } }