Item tracking improvements (#11919)

* Adding TrackedReferencesController

* Adding/changing views

* Adding/Editing js files

* RelationService changes

* RelationRepository changes

* Adding missing translations

* Adding/Modifying tests

* Beginning of #9125 migration

* Introducing a new component + refactoring based on that

* Abstracting + refactoring

* Work on content unpublishing

* Work on media.delete

* Various small changes

* Beginning of #9119 migration

* Changes on content.delete

* Various fixes

* Adding new keys used in the listview bulk actions

* Adding methods to get the items used in relations from array of ids

* Adding the checkLinkedItems function to the trackedReferencesResource

* Passing the selected items from a listview to unpublish and delete

* Adding umb-tracked-references-listview

* Adding umb-tracked-references-listview-table with language column

* Fixes for tracked references

* Changes in listview unpublish dialog

* Changes in listview delete dialog

* Removing Variants logic as it is not currently supported

* Visual fixes

* Closing dialogs on click

* Fix wording

* Fix breaking changes

* Change to a single title "Items in use" instead of 2 different for Content and Media

* No need for obsoleting because we can change new controllers

* Return ActionResult from actions

* V9:  Prevent delete or unpublish of items that have references (#12047)

* Introducing config settings that prevent delete or unpublish of items referenced by other items

* Disable deletion of content items and show a new warning

* Disable deletion of media items and show a new warning

* Disable deletion of list view items

* Disable unpublish and bulk unpublish

* Add a new warning

* V9: Displaying descendants in use as part of item tracking (#12039)

* Replace HasReferencesInDescendants with GetPagedDescendantsInReferences

* Display descendants in use on parent's info tab

* Add getPagedDescendantsInReferences to trackedReferencesResource

* Add lang keys for Descendants in use

* Refactoring controller actions

* Don't call check descendants usage when it is a new item

* rename busfy to busy

* always show references

* rearrange for scrollbar to appear at the edge of the dialog

* use the word referenced instead of used

* change fallback texts

* Added "IsDependency" to relation types

* refactor of umb-tracked-references

* rename checkLinkedItems to getPagedReferencedItems

* rename check to load, to be consistent with the rest.

* Refactored backend . Needs frontend fixes

* Cleanup

* Use filters

* Front-end refactor to match refactored end-points

* Fixed bug + warning

* Fixed query (more then 2100 descensdants) and optimized it (using nested select instead of inner join).

* remove comment

* hideNoneDependencies including varying text for the configuration

* Hack for SqlCE :(

* some final adjustments for item tracking ui

* Unbreak change

Co-authored-by: Niels Lyngsø <[email protected]>
Co-authored-by: Bjarke Berg <[email protected]>

Author: 3 people

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);
+    }
+}