Data type usage reporting and deletion warning

src/Umbraco.Core/Persistence/Repositories/IDataTypeRepository.cs

@@ -7,5 +7,12 @@ namespace Umbraco.Core.Persistence.Repositories
     public interface IDataTypeRepository : IReadWriteQueryRepository<int, IDataType>
     {
         IEnumerable<MoveEventInfo<IDataType>> Move(IDataType toMove, EntityContainer container);
+
+        /// <summary>
+        /// Returns a dictionary of content type <see cref="Udi"/>s and the property type aliases that use a <see cref="IDataType"/>
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        IReadOnlyDictionary<Udi, IEnumerable<string>> FindUsages(int id);
     }
 }

src/Umbraco.Core/Persistence/Repositories/Implement/DataTypeRepository.cs

@@ -279,6 +279,28 @@ public IEnumerable<MoveEventInfo<IDataType>> Move(IDataType toMove, EntityContai
             return moveInfo;
         }
 
+        public IReadOnlyDictionary<Udi, IEnumerable<string>> FindUsages(int id)
+        {
+            if (id == default)
+                return new Dictionary<Udi, IEnumerable<string>>();
+
+            var sql = Sql()
+                .Select<ContentTypeDto>(ct => ct.Select(node => node.NodeDto))
+                .AndSelect<PropertyTypeDto>(pt => Alias(pt.Alias, "ptAlias"), pt => Alias(pt.Name, "ptName"))
+                .From<PropertyTypeDto>()
+                .InnerJoin<ContentTypeDto>().On<ContentTypeDto, PropertyTypeDto>(ct => ct.NodeId, pt => pt.ContentTypeId)
+                .InnerJoin<NodeDto>().On<NodeDto, ContentTypeDto>(n => n.NodeId, ct => ct.NodeId)
+                .Where<PropertyTypeDto>(pt => pt.DataTypeId == id)
+                .OrderBy<NodeDto>(node => node.NodeId)
+                .AndBy<PropertyTypeDto>(pt => pt.Alias);
+
+            var dtos = Database.FetchOneToMany<ContentTypeReferenceDto>(ct => ct.PropertyTypes, sql);
+
+            return dtos.ToDictionary(
+                x => (Udi)new GuidUdi(ObjectTypes.GetUdiType(x.NodeDto.NodeObjectType.Value), x.NodeDto.UniqueId).EnsureClosed(),
+                x => (IEnumerable<string>)x.PropertyTypes.Select(p => p.Alias).ToList());
+        }
+
         private string EnsureUniqueNodeName(string nodeName, int id = 0)
         {
             var template = SqlContext.Templates.Get("Umbraco.Core.DataTypeDefinitionRepository.EnsureUniqueNodeName", tsql => tsql
@@ -291,5 +313,24 @@ private string EnsureUniqueNodeName(string nodeName, int id = 0)
 
             return SimilarNodeName.GetUniqueName(names, id, nodeName);
         }
+
+
+        [TableName(Constants.DatabaseSchema.Tables.ContentType)]
+        private class ContentTypeReferenceDto : ContentTypeDto
+        {
+            [ResultColumn]
+            [Reference(ReferenceType.Many)]
+            public List<PropertyTypeReferenceDto> PropertyTypes { get; set; }
+        }
+
+        [TableName(Constants.DatabaseSchema.Tables.PropertyType)]
+        private class PropertyTypeReferenceDto
+        {
+            [Column("ptAlias")]
+            public string Alias { get; set; }
+
+            [Column("ptName")]
+            public string Name { get; set; }
+        }
     }
 }

src/Umbraco.Core/Services/IContentTypeServiceBase.cs

@@ -25,7 +25,7 @@ public interface IContentTypeBaseService<TItem> : IContentTypeBaseService, IServ
         /// <summary>
         /// Gets a content type.
         /// </summary>
-        TItem Get(int id);
+        new TItem Get(int id);
 
         /// <summary>
         /// Gets a content type.
@@ -40,6 +40,7 @@ public interface IContentTypeBaseService<TItem> : IContentTypeBaseService, IServ
         int Count();
 
         IEnumerable<TItem> GetAll(params int[] ids);
+        IEnumerable<TItem> GetAll(IEnumerable<Guid> ids);
 
         IEnumerable<TItem> GetDescendants(int id, bool andSelf); // parent-child axis
         IEnumerable<TItem> GetComposedOf(int id); // composition axis

src/Umbraco.Core/Services/IDataTypeService.cs

@@ -10,6 +10,13 @@ namespace Umbraco.Core.Services
     /// </summary>
     public interface IDataTypeService : IService
     {
+        /// <summary>
+        /// Returns a dictionary of content type <see cref="Udi"/>s and the property type aliases that use a <see cref="IDataType"/>
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        IReadOnlyDictionary<Udi, IEnumerable<string>> GetReferences(int id);
+
         Attempt<OperationResult<OperationResultType, EntityContainer>> CreateContainer(int parentId, string name, int userId = Constants.Security.SuperUserId);
         Attempt<OperationResult> SaveContainer(EntityContainer container, int userId = Constants.Security.SuperUserId);
         EntityContainer GetContainer(int containerId);

src/Umbraco.Core/Services/Implement/ContentTypeServiceBaseOfTRepositoryTItemTService.cs

@@ -252,12 +252,12 @@ public IEnumerable<TItem> GetAll(params int[] ids)
             }
         }
 
-        public IEnumerable<TItem> GetAll(params Guid[] ids)
+        public IEnumerable<TItem> GetAll(IEnumerable<Guid> ids)
         {
             using (var scope = ScopeProvider.CreateScope(autoComplete: true))
             {
                 scope.ReadLock(ReadLockIds);
-                return Repository.GetMany(ids);
+                return Repository.GetMany(ids.ToArray());
             }
         }
 

src/Umbraco.Core/Services/Implement/DataTypeService.cs

@@ -466,6 +466,14 @@ public void Delete(IDataType dataType, int userId = Constants.Security.SuperUser
             }
         }
 
+        public IReadOnlyDictionary<Udi, IEnumerable<string>> GetReferences(int id)
+        {
+            using (var scope = ScopeProvider.CreateScope(autoComplete:true))
+            {
+                return _dataTypeRepository.FindUsages(id);
+            }
+        }
+
         private void Audit(AuditType type, int userId, int objectId)
         {
             _auditRepository.Save(new AuditItem(objectId, type, userId, ObjectTypes.GetName(UmbracoObjectTypes.DataType)));

src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs

@@ -28,6 +28,68 @@ private EntityContainerRepository CreateContainerRepository(IScopeAccessor scope
             return new EntityContainerRepository(scopeAccessor, AppCaches.Disabled, Logger, Constants.ObjectTypes.DataTypeContainer);
         }
 
+        [Test]
+        public void Can_Find_Usages()
+        {
+            var provider = TestObjects.GetScopeProvider(Logger);
+
+            using (provider.CreateScope())
+            {
+                var dtRepo = CreateRepository();
+                IDataType dataType1 = new DataType(new RadioButtonsPropertyEditor(Logger, ServiceContext.TextService)) { Name = "dt1" };
+                dtRepo.Save(dataType1);
+                IDataType dataType2 = new DataType(new RadioButtonsPropertyEditor(Logger, ServiceContext.TextService)) { Name = "dt2" };
+                dtRepo.Save(dataType2);
+
+                var ctRepo = Factory.GetInstance<IContentTypeRepository>();
+                IContentType ct = new ContentType(-1)
+                {
+                    Alias = "ct1",
+                    Name = "CT1",
+                    AllowedAsRoot = true,
+                    Icon = "icon-home",
+                    PropertyGroups = new PropertyGroupCollection
+                    {
+                        new PropertyGroup(true)
+                        {
+                            Name = "PG1",
+                            PropertyTypes = new PropertyTypeCollection(true)
+                            {
+                                new PropertyType(dataType1, "pt1")
+                                {
+                                    Name = "PT1"
+                                },
+                                new PropertyType(dataType1, "pt2")
+                                {
+                                    Name = "PT2"
+                                },
+                                new PropertyType(dataType2, "pt3")
+                                {
+                                    Name = "PT3"
+                                }
+                            }
+                        }
+                    }
+                };
+                ctRepo.Save(ct);
+
+                var usages = dtRepo.FindUsages(dataType1.Id);
+
+                var key = usages.First().Key;
+                Assert.AreEqual(ct.Key, ((GuidUdi)key).Guid);
+                Assert.AreEqual(2, usages[key].Count());
+                Assert.AreEqual("pt1", usages[key].ElementAt(0));
+                Assert.AreEqual("pt2", usages[key].ElementAt(1));
+
+                usages = dtRepo.FindUsages(dataType2.Id);
+
+                key = usages.First().Key;
+                Assert.AreEqual(ct.Key, ((GuidUdi)key).Guid);
+                Assert.AreEqual(1, usages[key].Count());
+                Assert.AreEqual("pt3", usages[key].ElementAt(0));
+            }
+        }
+
         [Test]
         public void Can_Move()
         {

src/Umbraco.Tests/TestHelpers/TestObjects-Mocks.cs

@@ -329,6 +329,11 @@ public Attempt<OperationResult<MoveOperationStatusType>> Move(IDataType toMove,
             {
                 throw new NotImplementedException();
             }
+
+            public IReadOnlyDictionary<Udi, IEnumerable<string>> GetReferences(int id)
+            {
+                throw new NotImplementedException();
+            }
         }
 
         #endregion

src/Umbraco.Web.UI.Client/src/common/resources/datatype.resource.js

@@ -43,6 +43,30 @@ function dataTypeResource($q, $http, umbDataFormatter, umbRequestHelper) {
                 "Failed to retrieve pre values for editor alias " + editorAlias);
         },
 
+        /**
+         * @ngdoc method
+         * @name umbraco.resources.dataTypeResource#getReferences
+         * @methodOf umbraco.resources.dataTypeResource
+         *
+         * @description
+         * Retrieves relations of a given data type.
+         *
+         * @param {Int} id id of datatype to retrieve relations for
+         * @returns {Promise} resourcePromise object.
+         *
+         */
+        getReferences: function (id) {            
+
+            return umbRequestHelper.resourcePromise(
+                $http.get(
+                    umbRequestHelper.getApiUrl(
+                        "dataTypeApiBaseUrl",
+                        "GetReferences",
+                        { id: id })),
+                "Failed to retrieve usages for data type of id " + id);
+
+        },
+
         /**
          * @ngdoc method
          * @name umbraco.resources.dataTypeResource#getById

src/Umbraco.Web.UI.Client/src/init.js

@@ -134,14 +134,14 @@ app.run(['$rootScope', '$route', '$location', 'urlHelper', 'navigationService',
 
                 var toRetain = navigationService.retainQueryStrings(currentRouteParams, next.params);
 
-                //if toRetain is not null it means that there are missing query strings and we need to update the current params
+                //if toRetain is not null it means that there are missing query strings and we need to update the current params.
                 if (toRetain) {
                     $route.updateParams(toRetain);
                 }
 
                 //check if the location being changed is only due to global/state query strings which means the location change
                 //isn't actually going to cause a route change.
-                if (!toRetain && navigationService.isRouteChangingNavigation(currentRouteParams, next.params)) {
+                if (navigationService.isRouteChangingNavigation(currentRouteParams, next.params)) {
 
                     //The location change will cause a route change, continue the route if the query strings haven't been updated.
                     $route.reload();