Merge remote-tracking branch 'origin/v8/feature/version-history-clean…

…up-ui' into v9/dev

# Conflicts:
#	src/Umbraco.Core/Composing/CompositionExtensions/Repositories.cs
#	src/Umbraco.Core/Composing/CompositionExtensions/Services.cs
#	src/Umbraco.Core/Configuration/UmbracoSettings/ContentElement.cs
#	src/Umbraco.Core/Configuration/UmbracoSettings/IContentSection.cs
#	src/Umbraco.Core/ContentEditing/HistoryCleanup.cs
#	src/Umbraco.Core/Models/ContentEditing/DocumentTypeDisplay.cs
#	src/Umbraco.Core/Models/ContentType.cs
#	src/Umbraco.Core/Models/Mapping/ContentTypeMapDefinition.cs
#	src/Umbraco.Core/Persistence/Repositories/DocumentVersionRepository.cs
#	src/Umbraco.Core/Scheduling/ContentVersionCleanup.cs
#	src/Umbraco.Core/Services/DefaultContentVersionCleanupPolicy.cs
#	src/Umbraco.Infrastructure/Migrations/Install/DatabaseSchemaCreator.cs
#	src/Umbraco.Infrastructure/Migrations/Upgrade/UmbracoPlan.cs
#	src/Umbraco.Infrastructure/Persistence/Repositories/Implement/ContentTypeCommonRepository.cs
#	src/Umbraco.Infrastructure/Services/Implement/ContentService.cs
#	src/Umbraco.Tests/Configurations/UmbracoSettings/umbracoSettings.config
#	src/Umbraco.Tests/TestHelpers/Entities/MockedContent.cs
#	src/Umbraco.Tests/TestHelpers/Entities/MockedContentTypes.cs
#	src/Umbraco.Tests/Umbraco.Tests.csproj
#	src/Umbraco.Web.UI.Client/package-lock.json
#	src/Umbraco.Web.UI/config/umbracoSettings.Release.config
#	src/Umbraco.Web.UI/umbraco/config/lang/en.xml
#	src/Umbraco.Web.UI/umbraco/config/lang/en_us.xml
#	src/Umbraco.Web/Scheduling/SchedulerComponent.cs
#	src/Umbraco.Web/Umbraco.Web.csproj
#	tests/Umbraco.Tests.Common/Extensions/AutoMoqDataAttribute.cs
#	tests/Umbraco.Tests.UnitTests/Umbraco.Core/Persistence/Repositories/DocumentVersionRepository_Tests_Integration.cs
#	tests/Umbraco.Tests.UnitTests/Umbraco.Core/Scheduling/ContentVersionCleanup_Tests_UnitTests.cs
#	tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/ContentVersionCleanupService_Tests_Integration.cs
#	tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/ContentVersionCleanupService_Tests_UnitTests.cs
#	tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/DefaultContentVersionCleanupPolicy_Tests_UnitTests.cs

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

@@ -219,6 +219,9 @@ @keyframes umbraco-preview-badge--effect {{
         [DefaultValue(StaticLoginLogoImage)]
         public string LoginLogoImage { get; set; } = StaticLoginLogoImage;
 
-
+        /// <summary>
+        /// Get or sets the model representing the global content version cleanup policy
+        /// </summary>
+        public ContentVersionCleanupPolicySettings ContentVersionCleanupPolicy { get; set; } = new ContentVersionCleanupPolicySettings();
     }
 }

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

@@ -0,0 +1,33 @@
+using System.ComponentModel;
+
+namespace Umbraco.Cms.Core.Configuration.Models
+{
+    /// <summary>
+    /// Model representing the global content version cleanup policy
+    /// </summary>
+    public class ContentVersionCleanupPolicySettings
+    {
+        private const bool StaticEnableCleanup = false;
+        private const int StaticKeepAllVersionsNewerThanDays = 2;
+        private const int StaticKeepLatestVersionPerDayForDays = 30;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether or not the cleanup job should be executed.
+        /// </summary>
+        [DefaultValue(StaticEnableCleanup)]
+        public bool EnableCleanup { get; set; } = StaticEnableCleanup;
+
+        /// <summary>
+        /// Gets or sets the number of days where all historical content versions are kept.
+        /// </summary>
+        [DefaultValue(StaticKeepAllVersionsNewerThanDays)]
+        public int KeepAllVersionsNewerThanDays { get; set; } = StaticKeepAllVersionsNewerThanDays;
+
+        /// <summary>
+        /// Gets or sets the number of days where the latest historical content version for that day are kept.
+        /// </summary>
+        [DefaultValue(StaticKeepLatestVersionPerDayForDays)]
+        public int KeepLatestVersionPerDayForDays { get; set; } = StaticKeepLatestVersionPerDayForDays;
+
+    }
+}

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

@@ -29,6 +29,9 @@ protected ContentTypeSave()
         [DataMember(Name = "allowedContentTypes")]
         public IEnumerable<int> AllowedContentTypes { get; set; }
 
+        [DataMember(Name = "historyCleanup")]
+        public HistoryCleanupViewModel HistoryCleanup { get; set; }
+
         /// <summary>
         /// Custom validation
         /// </summary>

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

@@ -6,28 +6,26 @@ namespace Umbraco.Cms.Core.Models.ContentEditing
     [DataContract(Name = "contentType", Namespace = "")]
     public class DocumentTypeDisplay : ContentTypeCompositionDisplay<PropertyTypeDisplay>
     {
-        public DocumentTypeDisplay()
-        {
+        public DocumentTypeDisplay() =>
             //initialize collections so at least their never null
             AllowedTemplates = new List<EntityBasic>();
-        }
 
         //name, alias, icon, thumb, desc, inherited from the content type
 
         // Templates
         [DataMember(Name = "allowedTemplates")]
         public IEnumerable<EntityBasic> AllowedTemplates { get; set; }
 
-        [DataMember(Name = "defaultTemplate")]
-        public EntityBasic DefaultTemplate { get; set; }
+        [DataMember(Name = "defaultTemplate")] public EntityBasic DefaultTemplate { get; set; }
 
         [DataMember(Name = "allowCultureVariant")]
         public bool AllowCultureVariant { get; set; }
 
         [DataMember(Name = "allowSegmentVariant")]
         public bool AllowSegmentVariant { get; set; }
 
-        [DataMember(Name = "apps")]
-        public IEnumerable<ContentApp> ContentApps { get; set; }
+        [DataMember(Name = "apps")] public IEnumerable<ContentApp> ContentApps { get; set; }
+
+        [DataMember(Name = "historyCleanup")] public HistoryCleanupViewModel HistoryCleanup { get; set; }
     }
 }

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

@@ -0,0 +1,16 @@
+using System.Runtime.Serialization;
+
+namespace Umbraco.Cms.Core.Models.ContentEditing
+{
+    [DataContract(Name = "historyCleanup", Namespace = "")]
+    public class HistoryCleanup
+    {
+        [DataMember(Name = "preventCleanup")] public bool PreventCleanup { get; set; }
+
+        [DataMember(Name = "keepAllVersionsNewerThanDays")]
+        public int? KeepAllVersionsNewerThanDays { get; set; }
+
+        [DataMember(Name = "keepLatestVersionPerDayForDays")]
+        public int? KeepLatestVersionPerDayForDays { get; set; }
+    }
+}

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

@@ -0,0 +1,17 @@
+using System.Runtime.Serialization;
+
+namespace Umbraco.Cms.Core.Models.ContentEditing
+{
+    [DataContract(Name = "historyCleanup", Namespace = "")]
+    public class HistoryCleanupViewModel : HistoryCleanup
+    {
+        [DataMember(Name = "globalKeepAllVersionsNewerThanDays")]
+        public int? GlobalKeepAllVersionsNewerThanDays { get;set; }
+
+        [DataMember(Name = "globalKeepLatestVersionPerDayForDays")]
+        public int? GlobalKeepLatestVersionPerDayForDays { get; set;}
+
+        [DataMember(Name = "globalEnableCleanup")]
+        public bool GlobalEnableCleanup { get; set; }
+    }
+}

src/Umbraco.Core/Models/ContentType.cs

@@ -2,68 +2,65 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.Serialization;
+using Umbraco.Cms.Core.Models.ContentEditing;
 using Umbraco.Cms.Core.Strings;
 using Umbraco.Extensions;
 
 namespace Umbraco.Cms.Core.Models
 {
     /// <summary>
-    /// Represents the content type that a <see cref="Content"/> object is based on
+    ///     Represents the content type that a <see cref="Content" /> object is based on
     /// </summary>
     [Serializable]
     [DataContract(IsReference = true)]
     public class ContentType : ContentTypeCompositionBase, IContentType
     {
         public const bool SupportsPublishingConst = true;
 
-        private int _defaultTemplate;
+
+        //Custom comparer for enumerable
+        private static readonly DelegateEqualityComparer<IEnumerable<ITemplate>> TemplateComparer = new(
+            (templates, enumerable) => templates.UnsortedSequenceEqual(enumerable),
+            templates => templates.GetHashCode());
+
         private IEnumerable<ITemplate> _allowedTemplates;
 
+        private int _defaultTemplate;
+
         /// <summary>
-        /// Constuctor for creating a ContentType with the parent's id.
+        ///     Constuctor for creating a ContentType with the parent's id.
         /// </summary>
         /// <remarks>Only use this for creating ContentTypes at the root (with ParentId -1).</remarks>
         /// <param name="parentId"></param>
-        public ContentType(IShortStringHelper shortStringHelper, int parentId) : base(shortStringHelper, parentId)
-        {
+        public ContentType(IShortStringHelper shortStringHelper, int parentId) : base(shortStringHelper, parentId) =>
             _allowedTemplates = new List<ITemplate>();
-        }
 
 
         /// <summary>
-        /// Constuctor for creating a ContentType with the parent as an inherited type.
+        ///     Constuctor for creating a ContentType with the parent as an inherited type.
         /// </summary>
         /// <remarks>Use this to ensure inheritance from parent.</remarks>
         /// <param name="parent"></param>
         /// <param name="alias"></param>
         public ContentType(IShortStringHelper shortStringHelper, IContentType parent, string alias)
-            : base(shortStringHelper, parent, alias)
-        {
+            : base(shortStringHelper, parent, alias) =>
             _allowedTemplates = new List<ITemplate>();
-        }
-
-        /// <inheritdoc />
-        public override ISimpleContentType ToSimple() => new SimpleContentType(this);
 
         /// <inheritdoc />
         public override bool SupportsPublishing => SupportsPublishingConst;
 
-        //Custom comparer for enumerable
-        private static readonly DelegateEqualityComparer<IEnumerable<ITemplate>> TemplateComparer = new DelegateEqualityComparer<IEnumerable<ITemplate>>(
-            (templates, enumerable) => templates.UnsortedSequenceEqual(enumerable),
-            templates => templates.GetHashCode());
+        /// <inheritdoc />
+        public override ISimpleContentType ToSimple() => new SimpleContentType(this);
 
         /// <summary>
-        /// Gets or sets the alias of the default Template.
-        /// TODO: This should be ignored from cloning!!!!!!!!!!!!!!
-        ///  - but to do that we have to implement callback hacks, this needs to be fixed in v8,
+        ///     Gets or sets the alias of the default Template.
+        ///     TODO: This should be ignored from cloning!!!!!!!!!!!!!!
+        ///     - but to do that we have to implement callback hacks, this needs to be fixed in v8,
         ///     we should not store direct entity
         /// </summary>
         [IgnoreDataMember]
-        public ITemplate DefaultTemplate
-        {
-            get { return AllowedTemplates.FirstOrDefault(x => x != null && x.Id == DefaultTemplateId); }
-        }
+        public ITemplate DefaultTemplate =>
+            AllowedTemplates.FirstOrDefault(x => x != null && x.Id == DefaultTemplateId);
 
 
         [DataMember]
@@ -74,9 +71,9 @@ public int DefaultTemplateId
         }
 
         /// <summary>
-        /// Gets or Sets a list of Templates which are allowed for the ContentType
-        /// TODO: This should be ignored from cloning!!!!!!!!!!!!!!
-        ///  - but to do that we have to implement callback hacks, this needs to be fixed in v8,
+        ///     Gets or Sets a list of Templates which are allowed for the ContentType
+        ///     TODO: This should be ignored from cloning!!!!!!!!!!!!!!
+        ///     - but to do that we have to implement callback hacks, this needs to be fixed in v8,
         ///     we should not store direct entity
         /// </summary>
         [DataMember]
@@ -85,41 +82,42 @@ public IEnumerable<ITemplate> AllowedTemplates
             get => _allowedTemplates;
             set
             {
-                SetPropertyValueAndDetectChanges(value, ref _allowedTemplates, nameof(AllowedTemplates), TemplateComparer);
+                SetPropertyValueAndDetectChanges(value, ref _allowedTemplates, nameof(AllowedTemplates),
+                    TemplateComparer);
 
                 if (_allowedTemplates.Any(x => x.Id == _defaultTemplate) == false)
+                {
                     DefaultTemplateId = 0;
+                }
             }
         }
 
+        public HistoryCleanup HistoryCleanup { get; set; }
+
         /// <summary>
-        /// Determines if AllowedTemplates contains templateId
+        ///     Determines if AllowedTemplates contains templateId
         /// </summary>
         /// <param name="templateId">The template id to check</param>
         /// <returns>True if AllowedTemplates contains the templateId else False</returns>
-        public bool IsAllowedTemplate(int templateId)
-        {
-            return AllowedTemplates == null
+        public bool IsAllowedTemplate(int templateId) =>
+            AllowedTemplates == null
                 ? false
                 : AllowedTemplates.Any(t => t.Id == templateId);
-        }
 
         /// <summary>
-        /// Determines if AllowedTemplates contains templateId
+        ///     Determines if AllowedTemplates contains templateId
         /// </summary>
         /// <param name="templateAlias">The template alias to check</param>
         /// <returns>True if AllowedTemplates contains the templateAlias else False</returns>
-        public bool IsAllowedTemplate(string templateAlias)
-        {
-            return AllowedTemplates == null
+        public bool IsAllowedTemplate(string templateAlias) =>
+            AllowedTemplates == null
                 ? false
                 : AllowedTemplates.Any(t => t.Alias.Equals(templateAlias, StringComparison.InvariantCultureIgnoreCase));
-        }
 
         /// <summary>
-        /// Sets the default template for the ContentType
+        ///     Sets the default template for the ContentType
         /// </summary>
-        /// <param name="template">Default <see cref="ITemplate"/></param>
+        /// <param name="template">Default <see cref="ITemplate" /></param>
         public void SetDefaultTemplate(ITemplate template)
         {
             if (template == null)
@@ -138,24 +136,27 @@ public void SetDefaultTemplate(ITemplate template)
         }
 
         /// <summary>
-        /// Removes a template from the list of allowed templates
+        ///     Removes a template from the list of allowed templates
         /// </summary>
-        /// <param name="template"><see cref="ITemplate"/> to remove</param>
+        /// <param name="template"><see cref="ITemplate" /> to remove</param>
         /// <returns>True if template was removed, otherwise False</returns>
         public bool RemoveTemplate(ITemplate template)
         {
             if (DefaultTemplateId == template.Id)
-                DefaultTemplateId = default(int);
+            {
+                DefaultTemplateId = default;
+            }
 
             var templates = AllowedTemplates.ToList();
-            var remove = templates.FirstOrDefault(x => x.Id == template.Id);
+            ITemplate remove = templates.FirstOrDefault(x => x.Id == template.Id);
             var result = templates.Remove(remove);
             AllowedTemplates = templates;
 
             return result;
         }
 
         /// <inheritdoc />
-        IContentType IContentType.DeepCloneWithResetIdentities(string newAlias) => (IContentType)DeepCloneWithResetIdentities(newAlias);
+        IContentType IContentType.DeepCloneWithResetIdentities(string newAlias) =>
+            (IContentType)DeepCloneWithResetIdentities(newAlias);
     }
 }

src/Umbraco.Core/Models/ContentVersionCleanupPolicySettings.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Umbraco.Core.Models
+{
+    public class ContentVersionCleanupPolicySettings
+    {
+        public int ContentTypeId { get; set; }
+        public int? KeepAllVersionsNewerThanDays { get; set; }
+        public int? KeepLatestVersionPerDayForDays { get; set; }
+        public bool PreventCleanup { get; set; }
+        public DateTime Updated { get; set; }
+    }
+}

src/Umbraco.Core/Models/HistoricContentVersionMeta.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace Umbraco.Cms.Core.Models
+{
+    public class HistoricContentVersionMeta
+    {
+        public int ContentId { get; }
+        public int ContentTypeId { get; }
+        public int VersionId { get; }
+        public DateTime VersionDate { get; }
+
+        public HistoricContentVersionMeta() { }
+
+        public HistoricContentVersionMeta(int contentId, int contentTypeId, int versionId, DateTime versionDate)
+        {
+            ContentId = contentId;
+            ContentTypeId = contentTypeId;
+            VersionId = versionId;
+            VersionDate = versionDate;
+        }
+
+        public override string ToString() => $"HistoricContentVersionMeta(versionId: {VersionId}, versionDate: {VersionDate:s}";
+    }
+}