Item tracking improvements

src/Umbraco.Core/Configuration/Models/ContentSettings.cs

@@ -157,6 +157,8 @@ @keyframes umbraco-preview-badge--effect {{
         internal const string StaticLoginBackgroundImage = "assets/img/login.jpg";
         internal const string StaticLoginLogoImage = "assets/img/application/umbraco_logo_white.svg";
         internal const bool StaticHideBackOfficeLogo = false;
+        internal const bool StaticDisableDeleteWhenReferenced = false;
+        internal const bool StaticDisableUnpublishWhenReferenced = false;
 
         /// <summary>
         /// Gets or sets a value for the content notification settings.
@@ -226,6 +228,18 @@ @keyframes umbraco-preview-badge--effect {{
         [DefaultValue(StaticHideBackOfficeLogo)]
         public bool HideBackOfficeLogo { get; set; } = StaticHideBackOfficeLogo;
 
+        /// <summary>
+        /// Gets or sets a value indicating whether to disable the deletion of items referenced by other items.
+        /// </summary>
+        [DefaultValue(StaticDisableDeleteWhenReferenced)]
+        public bool DisableDeleteWhenReferenced { get; set; } = StaticDisableDeleteWhenReferenced;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to disable the unpublishing of items referenced by other items.
+        /// </summary>
+        [DefaultValue(StaticDisableUnpublishWhenReferenced)]
+        public bool DisableUnpublishWhenReferenced { get; set; } = StaticDisableUnpublishWhenReferenced;
+
         /// <summary>
         /// Get or sets the model representing the global content version cleanup policy
         /// </summary>

src/Umbraco.Core/Events/RelateOnCopyNotificationHandler.cs

@@ -33,7 +33,8 @@ public void Handle(ContentCopiedNotification notification)
                     Constants.Conventions.RelationTypes.RelateDocumentOnCopyName,
                     true,
                     Constants.ObjectTypes.Document,
-                    Constants.ObjectTypes.Document);
+                    Constants.ObjectTypes.Document,
+                    false);
 
                 _relationService.Save(relationType);
             }

src/Umbraco.Core/Models/ContentEditing/RelationTypeDisplay.cs

@@ -55,5 +55,11 @@ public RelationTypeDisplay()
         /// </summary>
         [DataMember(Name = "notifications")]
         public List<BackOfficeNotification> Notifications { get; private set; }
+
+        /// <summary>
+        /// Gets or sets a boolean indicating whether the RelationType should be returned in "Used by"-queries.
+        /// </summary>
+        [DataMember(Name = "isDependency", IsRequired = true)]
+        public bool IsDependency { get; set; }
     }
 }

src/Umbraco.Core/Models/ContentEditing/RelationTypeSave.cs

@@ -23,5 +23,11 @@ public class RelationTypeSave : EntityBasic
         /// </summary>
         [DataMember(Name = "childObjectType", IsRequired = false)]
         public Guid? ChildObjectType { get; set; }
+
+        /// <summary>
+        /// Gets or sets a boolean indicating whether the RelationType should be returned in "Used by"-queries.
+        /// </summary>
+        [DataMember(Name = "isDependency", IsRequired = true)]
+        public bool IsDependency { get; set; }
     }
 }

src/Umbraco.Core/Models/IRelationType.cs

@@ -4,6 +4,15 @@
 
 namespace Umbraco.Cms.Core.Models
 {
+    public interface IRelationTypeWithIsDependency : IRelationType
+    {
+        /// <summary>
+        /// Gets or sets a boolean indicating whether the RelationType should be returned in "Used by"-queries.
+        /// </summary>
+        [DataMember]
+        bool IsDependency { get; set; }
+    }
+
     public interface IRelationType : IEntity, IRememberBeingDirty
     {
         /// <summary>

src/Umbraco.Core/Models/Mapping/RelationMapDefinition.cs

@@ -30,6 +30,11 @@ private void Map(IRelationType source, RelationTypeDisplay target, MapperContext
             target.ChildObjectType = source.ChildObjectType;
             target.Id = source.Id;
             target.IsBidirectional = source.IsBidirectional;
+
+            if (source is IRelationTypeWithIsDependency sourceWithIsDependency)
+            {
+                target.IsDependency = sourceWithIsDependency.IsDependency;
+            }
             target.Key = source.Key;
             target.Name = source.Name;
             target.Alias = source.Alias;
@@ -74,6 +79,11 @@ private static void Map(RelationTypeSave source, IRelationType target, MapperCon
             target.ChildObjectType = source.ChildObjectType;
             target.Id = source.Id.TryConvertTo<int>().Result;
             target.IsBidirectional = source.IsBidirectional;
+            if (target is IRelationTypeWithIsDependency targetWithIsDependency)
+            {
+                targetWithIsDependency.IsDependency = source.IsDependency;
+            }
+
             target.Key = source.Key;
             target.Name = source.Name;
             target.ParentObjectType = source.ParentObjectType;

src/Umbraco.Core/Models/RelationItem.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Runtime.Serialization;
+using Umbraco.Cms.Core.Models.Entities;
+
+namespace Umbraco.Cms.Core.Models
+{
+    [DataContract(Name = "relationItem", Namespace = "")]
+    public class RelationItem
+    {
+        [DataMember(Name = "id")]
+        public int NodeId { get; set; }
+
+        [DataMember(Name = "key")]
+        public Guid NodeKey { get; set; }
+
+        [DataMember(Name = "name")]
+        public string NodeName { get; set; }
+
+        [DataMember(Name = "type")]
+        public string NodeType { get; set; }
+
+        [DataMember(Name = "udi")]
+        public Udi NodeUdi => Udi.Create(NodeType, NodeKey);
+
+        [DataMember(Name = "icon")]
+        public string ContentTypeIcon { get; set; }
+
+        [DataMember(Name = "alias")]
+        public string ContentTypeAlias { get; set; }
+
+        [DataMember(Name = "contentTypeName")]
+        public string ContentTypeName { get; set; }
+
+        [DataMember(Name = "relationTypeName")]
+        public string RelationTypeName { get; set; }
+
+        [DataMember(Name = "relationTypeIsBidirectional")]
+        public bool RelationTypeIsBidirectional { get; set; }
+
+        [DataMember(Name = "relationTypeIsDependency")]
+        public bool RelationTypeIsDependency { get; set; }
+
+    }
+}

src/Umbraco.Core/Models/RelationType.cs

@@ -9,20 +9,28 @@ namespace Umbraco.Cms.Core.Models
     /// </summary>
     [Serializable]
     [DataContract(IsReference = true)]
-    public class RelationType : EntityBase, IRelationType
+    public class RelationType : EntityBase, IRelationType, IRelationTypeWithIsDependency
     {
         private string _name;
         private string _alias;
         private bool _isBidirectional;
+        private bool _isDependency;
         private Guid? _parentObjectType;
         private Guid? _childObjectType;
 
         public RelationType(string alias, string name)
-            : this(name: name, alias: alias, false, null, null)
+            : this(name: name, alias: alias, false, null, null, false)
         {
         }
 
+        [Obsolete("Use ctor with isDependency parameter")]
         public RelationType(string name, string alias, bool isBidrectional, Guid? parentObjectType, Guid? childObjectType)
+        :this(name,alias,isBidrectional, parentObjectType, childObjectType, false)
+        {
+
+        }
+
+        public RelationType(string name, string alias, bool isBidrectional, Guid? parentObjectType, Guid? childObjectType, bool isDependency)
         {
             if (name == null) throw new ArgumentNullException(nameof(name));
             if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
@@ -32,6 +40,7 @@ public RelationType(string name, string alias, bool isBidrectional, Guid? parent
             _name = name;
             _alias = alias;
             _isBidirectional = isBidrectional;
+            _isDependency = isDependency;
             _parentObjectType = parentObjectType;
             _childObjectType = childObjectType;
         }
@@ -88,5 +97,11 @@ public Guid? ChildObjectType
             set => SetPropertyValueAndDetectChanges(value, ref _childObjectType, nameof(ChildObjectType));
         }
 
+
+        public bool IsDependency
+        {
+            get => _isDependency;
+            set => SetPropertyValueAndDetectChanges(value, ref _isDependency, nameof(IsDependency));
+        }
     }
 }

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

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.Entities;

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

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Entities;
+
+namespace Umbraco.Cms.Core.Persistence.Repositories
+{
+    public interface ITrackedReferencesRepository
+    {
+        IEnumerable<RelationItem> GetPagedRelationsForItems(int[] ids, long pageIndex, int pageSize, bool filterMustBeIsDependency,out long totalRecords);
+        IEnumerable<RelationItem> GetPagedItemsWithRelations(int[] ids, long pageIndex, int pageSize, bool filterMustBeIsDependency,out long totalRecords);
+        IEnumerable<RelationItem> GetPagedDescendantsInReferences(int parentId, long pageIndex, int pageSize, bool filterMustBeIsDependency,out long totalRecords);
+    }
+}

src/Umbraco.Core/Services/IRelationService.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.Entities;
@@ -215,7 +215,7 @@ public interface IRelationService : IService
         /// <param name="pageIndex"></param>
         /// <param name="pageSize"></param>
         /// <param name="totalChildren"></param>
-        /// <returns></returns>
+        /// <returns>An enumerable list of <see cref="IUmbracoEntity"/></returns>
         IEnumerable<IUmbracoEntity> GetPagedParentEntitiesByChildId(int id, long pageIndex, int pageSize, out long totalChildren, params UmbracoObjectTypes[] entityTypes);
 
         /// <summary>
@@ -225,7 +225,7 @@ public interface IRelationService : IService
         /// <param name="pageIndex"></param>
         /// <param name="pageSize"></param>
         /// <param name="totalChildren"></param>
-        /// <returns></returns>
+        /// <returns>An enumerable list of <see cref="IUmbracoEntity"/></returns>
         IEnumerable<IUmbracoEntity> GetPagedChildEntitiesByParentId(int id, long pageIndex, int pageSize, out long totalChildren, params UmbracoObjectTypes[] entityTypes);
 
         /// <summary>

src/Umbraco.Core/Services/ITrackedReferencesService.cs

@@ -0,0 +1,15 @@
+using Umbraco.Cms.Core.Models;
+
+namespace Umbraco.Cms.Core.Services
+{
+    public interface ITrackedReferencesService
+    {
+        PagedResult<RelationItem> GetPagedRelationsForItems(int[] ids, long pageIndex, int pageSize, bool filterMustBeIsDependency);
+
+
+        PagedResult<RelationItem> GetPagedDescendantsInReferences(int parentId, long pageIndex, int pageSize, bool filterMustBeIsDependency);
+
+
+        PagedResult<RelationItem> GetPagedItemsWithRelations(int[] ids, long pageIndex, int pageSize, bool filterMustBeIsDependency);
+    }
+}

src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Repositories.cs

@@ -47,6 +47,7 @@ internal static IUmbracoBuilder AddRepositories(this IUmbracoBuilder builder)
             builder.Services.AddUnique<IPublicAccessRepository, PublicAccessRepository>();
             builder.Services.AddUnique<IRedirectUrlRepository, RedirectUrlRepository>();
             builder.Services.AddUnique<IRelationRepository, RelationRepository>();
+            builder.Services.AddUnique<ITrackedReferencesRepository, TrackedReferencesRepository>();
             builder.Services.AddUnique<IRelationTypeRepository, RelationTypeRepository>();
             builder.Services.AddUnique<IServerRegistrationRepository, ServerRegistrationRepository>();
             builder.Services.AddUnique<ITagRepository, TagRepository>();

src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Services.cs

@@ -63,6 +63,7 @@ internal static IUmbracoBuilder AddServices(this IUmbracoBuilder builder)
             builder.Services.AddUnique<IServerRegistrationService, ServerRegistrationService>();
             builder.Services.AddUnique<IEntityService, EntityService>();
             builder.Services.AddUnique<IRelationService, RelationService>();
+            builder.Services.AddUnique<ITrackedReferencesService, TrackedReferencesService>();
             builder.Services.AddUnique<IMacroService, MacroService>();
             builder.Services.AddUnique<IMemberTypeService, MemberTypeService>();
             builder.Services.AddUnique<IMemberGroupService, MemberGroupService>();

src/Umbraco.Infrastructure/Events/RelateOnTrashNotificationHandler.cs

@@ -65,7 +65,7 @@ public void Handle(ContentMovedToRecycleBinNotification notification)
                     var documentObjectType = Constants.ObjectTypes.Document;
                     const string relationTypeName = Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteName;
 
-                    relationType = new RelationType(relationTypeName, relationTypeAlias, false, documentObjectType, documentObjectType);
+                    relationType = new RelationType(relationTypeName, relationTypeAlias, false, documentObjectType, documentObjectType, false);
                     _relationService.Save(relationType);
                 }
 
@@ -123,7 +123,7 @@ public void Handle(MediaMovedToRecycleBinNotification notification)
                 {
                     var documentObjectType = Constants.ObjectTypes.Document;
                     const string relationTypeName = Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteName;
-                    relationType = new RelationType(relationTypeName, relationTypeAlias, false, documentObjectType, documentObjectType);
+                    relationType = new RelationType(relationTypeName, relationTypeAlias, false, documentObjectType, documentObjectType, false);
                     _relationService.Save(relationType);
                 }
 

src/Umbraco.Infrastructure/Migrations/Install/DatabaseDataCreator.cs

@@ -421,21 +421,21 @@ void InsertDataTypeDto(int id, string editorAlias, string dbType, string configu
 
         private void CreateRelationTypeData()
         {
-            var relationType = new RelationTypeDto { Id = 1, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelateDocumentOnCopyAlias, ChildObjectType = Cms.Core.Constants.ObjectTypes.Document, ParentObjectType = Cms.Core.Constants.ObjectTypes.Document, Dual = true, Name = Cms.Core.Constants.Conventions.RelationTypes.RelateDocumentOnCopyName };
+            var relationType = new RelationTypeDto { Id = 1, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelateDocumentOnCopyAlias, ChildObjectType = Cms.Core.Constants.ObjectTypes.Document, ParentObjectType = Cms.Core.Constants.ObjectTypes.Document, Dual = true, Name = Cms.Core.Constants.Conventions.RelationTypes.RelateDocumentOnCopyName, IsDependency = false};
             relationType.UniqueId = CreateUniqueRelationTypeId(relationType.Alias, relationType.Name);
             _database.Insert(Cms.Core.Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
-            relationType = new RelationTypeDto { Id = 2, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteAlias, ChildObjectType = Cms.Core.Constants.ObjectTypes.Document, ParentObjectType = Cms.Core.Constants.ObjectTypes.Document, Dual = false, Name = Cms.Core.Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteName };
+            relationType = new RelationTypeDto { Id = 2, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteAlias, ChildObjectType = Cms.Core.Constants.ObjectTypes.Document, ParentObjectType = Cms.Core.Constants.ObjectTypes.Document, Dual = false, Name = Cms.Core.Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteName, IsDependency = false };
             relationType.UniqueId = CreateUniqueRelationTypeId(relationType.Alias, relationType.Name);
             _database.Insert(Cms.Core.Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
-            relationType = new RelationTypeDto { Id = 3, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteAlias, ChildObjectType = Cms.Core.Constants.ObjectTypes.Media, ParentObjectType = Cms.Core.Constants.ObjectTypes.Media, Dual = false, Name = Cms.Core.Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteName };
+            relationType = new RelationTypeDto { Id = 3, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteAlias, ChildObjectType = Cms.Core.Constants.ObjectTypes.Media, ParentObjectType = Cms.Core.Constants.ObjectTypes.Media, Dual = false, Name = Cms.Core.Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteName, IsDependency = false };
             relationType.UniqueId = CreateUniqueRelationTypeId(relationType.Alias, relationType.Name);
             _database.Insert(Cms.Core.Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
 
-            relationType = new RelationTypeDto { Id = 4, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelatedMediaAlias, ChildObjectType = null, ParentObjectType = null, Dual = false, Name = Cms.Core.Constants.Conventions.RelationTypes.RelatedMediaName };
+            relationType = new RelationTypeDto { Id = 4, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelatedMediaAlias, ChildObjectType = null, ParentObjectType = null, Dual = false, Name = Cms.Core.Constants.Conventions.RelationTypes.RelatedMediaName, IsDependency = true };
             relationType.UniqueId = CreateUniqueRelationTypeId(relationType.Alias, relationType.Name);
             _database.Insert(Cms.Core.Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
 
-            relationType = new RelationTypeDto { Id = 5, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelatedDocumentAlias, ChildObjectType = null, ParentObjectType = null, Dual = false, Name = Cms.Core.Constants.Conventions.RelationTypes.RelatedDocumentName };
+            relationType = new RelationTypeDto { Id = 5, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelatedDocumentAlias, ChildObjectType = null, ParentObjectType = null, Dual = false, Name = Cms.Core.Constants.Conventions.RelationTypes.RelatedDocumentName, IsDependency = true };
             relationType.UniqueId = CreateUniqueRelationTypeId(relationType.Alias, relationType.Name);
             _database.Insert(Cms.Core.Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
         }

src/Umbraco.Infrastructure/Migrations/Upgrade/UmbracoPlan.cs

@@ -283,6 +283,7 @@ protected void DefinePlan()
 
             // TO 9.4.0
             To<AddScheduledPublishingLock>("{DBBA1EA0-25A1-4863-90FB-5D306FB6F1E1}");
+            To<UpdateRelationTypesToHandleDependencies>("{DED98755-4059-41BB-ADBD-3FEAB12D1D7B}");
         }
     }
 }

src/Umbraco.Infrastructure/Migrations/Upgrade/V_9_4_0/UpdateRelationTypesToHandleDependencies.cs

@@ -0,0 +1,34 @@
+using System.Linq;
+using Umbraco.Cms.Infrastructure.Persistence.Dtos;
+using Umbraco.Extensions;
+
+
+namespace Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_9_4_0
+{
+    internal class UpdateRelationTypesToHandleDependencies : MigrationBase
+    {
+        public UpdateRelationTypesToHandleDependencies(IMigrationContext context)
+            : base(context)
+        {
+        }
+
+        protected override void Migrate()
+        {
+            var columns = SqlSyntax.GetColumnsInSchema(Context.Database).ToList();
+
+            AddColumnIfNotExists<RelationTypeDto>(columns, "isDependency");
+
+            var aliasesWithDependencies = new[]
+            {
+                Core.Constants.Conventions.RelationTypes.RelatedDocumentAlias,
+                Core.Constants.Conventions.RelationTypes.RelatedMediaAlias
+            };
+
+            Database.Execute(
+                Sql()
+                    .Update<RelationTypeDto>(u => u.Set(x => x.IsDependency, true))
+                    .WhereIn<RelationTypeDto>(x => x.Alias, aliasesWithDependencies));
+
+        }
+    }
+}

src/Umbraco.Infrastructure/Persistence/Dtos/RelationTypeDto.cs

@@ -40,5 +40,9 @@ internal class RelationTypeDto
         [Length(100)]
         [Index(IndexTypes.UniqueNonClustered, Name = "IX_umbracoRelationType_alias")]
         public string Alias { get; set; }
+
+        [Constraint(Default = "0")]
+        [Column("isDependency")]
+        public bool IsDependency { get; set; }
     }
 }