Merge remote-tracking branch 'origin/temp8' into temp8-231-send-to-publish-with-variants

# Conflicts:
#	src/Umbraco.Core/Services/Implement/ContentService.cs

src/Umbraco.Core/ContentVariationExtensions.cs

@@ -115,7 +115,7 @@ namespace Umbraco.Core
         /// <summary>
         /// Determines whether a variation varies by culture and segment.
         /// </summary>
-        public static bool VariesByCultureAndSegment(this ContentVariation variation) => (variation & ContentVariation.CultureAndSegment) > 0;
+        public static bool VariesByCultureAndSegment(this ContentVariation variation) => (variation & ContentVariation.CultureAndSegment) == ContentVariation.CultureAndSegment;
 
         /// <summary>
         /// Validates that a combination of culture and segment is valid for the variation.

src/Umbraco.Core/Models/ApplicationTree.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Diagnostics;
+using Umbraco.Core.Services;
 
 namespace Umbraco.Core.Models
 {
@@ -35,6 +36,7 @@ namespace Umbraco.Core.Models
             IconClosed = iconClosed;
             IconOpened = iconOpened;
             Type = type;
+            
         }
 
         /// <summary>
@@ -85,6 +87,33 @@ namespace Umbraco.Core.Models
         /// <value>The type.</value>
         public string Type { get; set; }
 
+        /// <summary>
+        /// Returns the localized root node display name
+        /// </summary>
+        /// <param name="textService"></param>
+        /// <returns></returns>
+        public string GetRootNodeDisplayName(ILocalizedTextService textService)
+        {
+            var label = $"[{Alias}]";
+
+            // try to look up a the localized tree header matching the tree alias
+            var localizedLabel = textService.Localize("treeHeaders/" + Alias);
+
+            // if the localizedLabel returns [alias] then return the title attribute from the trees.config file, if it's defined
+            if (localizedLabel != null && localizedLabel.Equals(label, StringComparison.InvariantCultureIgnoreCase))
+            {
+                if (string.IsNullOrEmpty(Title) == false)
+                    label = Title;
+            }
+            else
+            {
+                // the localizedLabel translated into something that's not just [alias], so use the translation
+                label = localizedLabel;
+            }
+
+            return label;
+        }
+
         private Type _runtimeType;
 
         /// <summary>

src/Umbraco.Core/Models/ContentCultureInfos.cs

@@ -28,11 +28,11 @@ namespace Umbraco.Core.Models
         /// Initializes a new instance of the <see cref="ContentCultureInfos"/> class.
         /// </summary>
         /// <remarks>Used for cloning, without change tracking.</remarks>
-        private ContentCultureInfos(string culture, string name, DateTime date)
-            : this(culture)
+        internal ContentCultureInfos(ContentCultureInfos other)
+            : this(other.Culture)
         {
-            _name = name;
-            _date = date;
+            _name = other.Name;
+            _date = other.Date;
         }
 
         /// <summary>
@@ -61,7 +61,7 @@ namespace Umbraco.Core.Models
         /// <inheritdoc />
         public object DeepClone()
         {
-            return new ContentCultureInfos(Culture, Name, Date);
+            return new ContentCultureInfos(this);
         }
 
         /// <inheritdoc />

src/Umbraco.Core/Models/ContentCultureInfosCollection.cs

@@ -24,8 +24,12 @@ namespace Umbraco.Core.Models
         public ContentCultureInfosCollection(IEnumerable<ContentCultureInfos> items)
             : base(x => x.Culture, StringComparer.InvariantCultureIgnoreCase)
         {
+            // make sure to add *copies* and not the original items,
+            // as items can be modified by AddOrUpdate, and therefore
+            // the new collection would be impacted by changes made
+            // to the old collection
             foreach (var item in items)
-                Add(item);
+                Add(new ContentCultureInfos(item));
         }
         
         /// <summary>

src/Umbraco.Core/Models/ContentTypeBaseExtensions.cs

@@ -63,20 +63,5 @@ namespace Umbraco.Core.Models
             aliases = a;
             return hasAnyPropertyVariationChanged;
         }
-
-        /// <summary>
-        /// Returns the list of content types the composition is used in
-        /// </summary>
-        /// <param name="allContentTypes"></param>
-        /// <param name="source"></param>
-        /// <returns></returns>
-        internal static IEnumerable<IContentTypeComposition> GetWhereCompositionIsUsedInContentTypes(this IContentTypeComposition source,
-            IContentTypeComposition[] allContentTypes)
-        {
-            var sourceId = source != null ? source.Id : 0;
-
-            // find which content types are using this composition
-            return allContentTypes.Where(x => x.ContentTypeComposition.Any(y => y.Id == sourceId)).ToArray();
-        }
     }
 }

src/Umbraco.Core/Models/ContentTypeCompositionBase.cs

@@ -114,6 +114,27 @@ namespace Umbraco.Core.Models
             }
         }
 
+        /// <summary>
+        /// Gets the property types obtained via composition.
+        /// </summary>
+        /// <remarks>
+        /// <para>Gets them raw, ie with their original variation.</para>
+        /// </remarks>
+        [IgnoreDataMember]
+        internal IEnumerable<PropertyType> RawComposedPropertyTypes => GetRawComposedPropertyTypes();
+
+        private IEnumerable<PropertyType> GetRawComposedPropertyTypes(bool start = true)
+        {
+            var propertyTypes = ContentTypeComposition
+                .Cast<ContentTypeCompositionBase>()
+                .SelectMany(x => start ? x.GetRawComposedPropertyTypes(false) : x.CompositionPropertyTypes);
+
+            if (!start)
+                propertyTypes = propertyTypes.Union(PropertyTypes);
+
+            return propertyTypes;
+        }
+
         /// <summary>
         /// Adds a content type to the composition.
         /// </summary>

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

@@ -11,13 +11,6 @@ namespace Umbraco.Core.Persistence.Repositories
         TItem Get(string alias);
         IEnumerable<MoveEventInfo<TItem>> Move(TItem moving, EntityContainer container);
 
-        /// <summary>
-        /// Returns the content types that are direct compositions of the content type
-        /// </summary>
-        /// <param name="id">The content type id</param>
-        /// <returns></returns>
-        IEnumerable<TItem> GetTypesDirectlyComposedOf(int id);
-
         /// <summary>
         /// Derives a unique alias from an existing alias.
         /// </summary>

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

@@ -67,7 +67,6 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
             return ContentTypeQueryMapper.GetContentTypes(Database, SqlSyntax, IsPublishing, this, _templateRepository);
         }
 
-
         protected override IEnumerable<IContentType> PerformGetAll(params Guid[] ids)
         {
             // use the underlying GetAll which will force cache all content types

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

@@ -119,7 +119,6 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
 
         protected void PersistNewBaseContentType(IContentTypeComposition entity)
         {
-
             var dto = ContentTypeFactory.BuildContentTypeDto(entity);
 
             //Cannot add a duplicate content type type
@@ -234,7 +233,6 @@ AND umbracoNode.nodeObjectType = @objectType",
 
         protected void PersistUpdatedBaseContentType(IContentTypeComposition entity)
         {
-
             var dto = ContentTypeFactory.BuildContentTypeDto(entity);
 
             // ensure the alias is not used already
@@ -270,8 +268,8 @@ AND umbracoNode.id <> @id",
             // 1. Find content based on the current ContentType: entity.Id
             // 2. Find all PropertyTypes on the ContentType that was removed - tracked id (key)
             // 3. Remove properties based on property types from the removed content type where the content ids correspond to those found in step one
-            var compositionBase = entity as ContentTypeCompositionBase;
-            if (compositionBase != null && compositionBase.RemovedContentTypeKeyTracker != null &&
+            if (entity is ContentTypeCompositionBase compositionBase &&
+                compositionBase.RemovedContentTypeKeyTracker != null &&
                 compositionBase.RemovedContentTypeKeyTracker.Any())
             {
                 //TODO: Could we do the below with bulk SQL statements instead of looking everything up and then manipulating?
@@ -314,7 +312,7 @@ AND umbracoNode.id <> @id",
                 }
             }
 
-            // delete the allowed content type entries before re-inserting the collectino of allowed content types
+            // delete the allowed content type entries before re-inserting the collection of allowed content types
             Database.Delete<ContentTypeAllowedContentTypeDto>("WHERE Id = @Id", new { entity.Id });
             foreach (var allowedContentType in entity.AllowedContentTypes)
             {
@@ -409,40 +407,34 @@ AND umbracoNode.id <> @id",
             }
 
             //check if the content type variation has been changed
-            var ctVariationChanging = entity.IsPropertyDirty("Variations");
-            if (ctVariationChanging)
+            var contentTypeVariationDirty = entity.IsPropertyDirty("Variations");
+            var oldContentTypeVariation = (ContentVariation) dtoPk.Variations;
+            var newContentTypeVariation = entity.Variations;
+            var contentTypeVariationChanging = contentTypeVariationDirty && oldContentTypeVariation != newContentTypeVariation;
+            if (contentTypeVariationChanging)
             {
-                //we've already looked up the previous version of the content type so we know it's previous variation state
-                MoveVariantData(entity, (ContentVariation)dtoPk.Variations, entity.Variations);
+                MoveContentTypeVariantData(entity, oldContentTypeVariation, newContentTypeVariation);
                 Clear301Redirects(entity);
                 ClearScheduledPublishing(entity);
-            }   
+            }
 
-            //track any content type/property types that are changing variation which will require content updates
-            var propertyTypeVariationChanges = new Dictionary<int, ContentVariation>();
+            // collect property types that have a dirty variation
+            List<PropertyType> propertyTypeVariationDirty = null;
 
-            // insert or update properties
-            // all of them, no-group and in-groups
+            // note: this only deals with *local* property types, we're dealing w/compositions later below
             foreach (var propertyType in entity.PropertyTypes)
             {
-                //if the content type variation isn't changing track if any property type is changing
-                if (!ctVariationChanging)
+                if (contentTypeVariationChanging)
                 {
-                    if (propertyType.IsPropertyDirty("Variations"))
+                    // content type is changing
+                    switch (newContentTypeVariation)
                     {
-                        propertyTypeVariationChanges[propertyType.Id] = propertyType.Variations;
-                    }   
-                }
-                else
-                {
-                    switch(entity.Variations)
-                    {
-                        case ContentVariation.Nothing:
-                            //if the content type is changing to Nothing, then all property type's must change to nothing
+                        case ContentVariation.Nothing: // changing to Nothing
+                            // all property types must change to Nothing
                             propertyType.Variations = ContentVariation.Nothing;
                             break;
-                        case ContentVariation.Culture:
-                            //we don't need to modify the property type in this case
+                        case ContentVariation.Culture: // changing to Culture
+                            // all property types can remain Nothing
                             break;
                         case ContentVariation.CultureAndSegment:
                         case ContentVariation.Segment:
@@ -451,15 +443,65 @@ AND umbracoNode.id <> @id",
                     }
                 }
 
-                var groupId = propertyType.PropertyGroupId?.Value ?? default(int);
+                // then, track each property individually
+                if (propertyType.IsPropertyDirty("Variations"))
+                {
+                    // allocate the list only when needed
+                    if (propertyTypeVariationDirty == null)
+                        propertyTypeVariationDirty = new List<PropertyType>();
+
+                    propertyTypeVariationDirty.Add(propertyType);
+                }
+            }
+
+            // figure out dirty property types that have actually changed
+            // before we insert or update properties, so we can read the old variations
+            var propertyTypeVariationChanges = propertyTypeVariationDirty != null
+                ? GetPropertyVariationChanges(propertyTypeVariationDirty)
+                : null;
+
+            // deal with composition property types
+            // add changes for property types obtained via composition, which change due
+            // to this content type variations change
+            if (contentTypeVariationChanging)
+            {
+                // must use RawComposedPropertyTypes here: only those types that are obtained
+                // via composition, with their original variations (ie not filtered by this
+                // content type variations - we need this true value to make decisions.
+
+                foreach (var propertyType in ((ContentTypeCompositionBase) entity).RawComposedPropertyTypes)
+                {
+                    if (propertyType.VariesBySegment() || newContentTypeVariation.VariesBySegment())
+                        throw new NotSupportedException(); // TODO: support this
+
+                    if (propertyType.Variations == ContentVariation.Culture)
+                    {
+                        if (propertyTypeVariationChanges == null)
+                            propertyTypeVariationChanges = new Dictionary<int, (ContentVariation, ContentVariation)>();
+
+                        // if content type moves to Culture, property type becomes Culture here again
+                        // if content type moves to Nothing, property type becomes Nothing here
+                        if (newContentTypeVariation == ContentVariation.Culture)
+                            propertyTypeVariationChanges[propertyType.Id] = (ContentVariation.Nothing, ContentVariation.Culture);
+                        else if (newContentTypeVariation == ContentVariation.Nothing)
+                            propertyTypeVariationChanges[propertyType.Id] = (ContentVariation.Culture, ContentVariation.Nothing);
+                    }
+                }
+            }
+
+            // insert or update properties
+            // all of them, no-group and in-groups
+            foreach (var propertyType in entity.PropertyTypes)
+            {
                 // if the Id of the DataType is not set, we resolve it from the db by its PropertyEditorAlias
-                if (propertyType.DataTypeId == 0 || propertyType.DataTypeId == default(int))
+                if (propertyType.DataTypeId == 0 || propertyType.DataTypeId == default)
                     AssignDataTypeFromPropertyEditor(propertyType);
 
                 // validate the alias
                 ValidateAlias(propertyType);
 
                 // insert or update property
+                var groupId = propertyType.PropertyGroupId?.Value ?? default;
                 var propertyTypeDto = PropertyGroupFactory.BuildPropertyTypeDto(groupId, propertyType, entity.Id);
                 var typeId = propertyType.HasIdentity
                     ? Database.Update(propertyTypeDto)
@@ -470,31 +512,22 @@ AND umbracoNode.id <> @id",
                     typeId = propertyType.Id;
 
                 // not an orphan anymore
-                if (orphanPropertyTypeIds != null)
-                    orphanPropertyTypeIds.Remove(typeId);
+                orphanPropertyTypeIds?.Remove(typeId);
             }
 
-            //check if any property types were changing variation
-            if (propertyTypeVariationChanges.Count > 0)
-            {
-                var changes = new Dictionary<int, (ContentVariation, ContentVariation)>();
+            // must restrict property data changes to impacted content types - if changing a composing
+            // type, some composed types (those that do not vary) are not impacted and should be left
+            // unchanged
+            //
+            // getting 'all' from the cache policy is prone to race conditions - fast but dangerous
+            //var all = ((FullDataSetRepositoryCachePolicy<TEntity, int>)CachePolicy).GetAllCached(PerformGetAll);
+            var all = PerformGetAll();
 
-                //now get the current property type variations for the changed ones so that we know which variation they
-                //are going from and to
-                var from = Database.Dictionary<int, byte>(Sql()
-                    .Select<PropertyTypeDto>(x => x.Id, x => x.Variations)
-                    .From<PropertyTypeDto>()
-                    .WhereIn<PropertyTypeDto>(x => x.Id, propertyTypeVariationChanges.Keys));
-
-                foreach (var f in from)
-                {
-                    changes[f.Key] = (propertyTypeVariationChanges[f.Key], (ContentVariation)f.Value);
-                }
-
-                //perform the move
-                MoveVariantData(changes);
-            }
+            var impacted = GetImpactedContentTypes(entity, all);
 
+            // if some property types have actually changed, move their variant data
+            if (propertyTypeVariationChanges != null)
+                MovePropertyTypeVariantData(propertyTypeVariationChanges, impacted);
 
             // deal with orphan properties: those that were in a deleted tab,
             // and have not been re-mapped to another tab or to 'generic properties'
@@ -503,6 +536,77 @@ AND umbracoNode.id <> @id",
                     DeletePropertyType(entity.Id, id);
         }
 
+        private IEnumerable<IContentTypeComposition> GetImpactedContentTypes(IContentTypeComposition contentType, IEnumerable<IContentTypeComposition> all)
+        {
+            var impact = new List<IContentTypeComposition>();
+            var set = new List<IContentTypeComposition> { contentType };
+
+            var tree = new Dictionary<int, List<IContentTypeComposition>>();
+            foreach (var x in all)
+            foreach (var y in x.ContentTypeComposition)
+            {
+                if (!tree.TryGetValue(y.Id, out var list))
+                    list = tree[y.Id] = new List<IContentTypeComposition>();
+                list.Add(x);
+            }
+
+            var nset = new List<IContentTypeComposition>();
+            do
+            {
+                impact.AddRange(set);
+
+                foreach (var x in set)
+                {
+                    if (!tree.TryGetValue(x.Id, out var list)) continue;
+                    nset.AddRange(list.Where(y => y.VariesByCulture()));
+                }
+
+                set = nset;
+                nset = new List<IContentTypeComposition>();
+            } while (set.Count > 0);
+
+            return impact;
+        }
+
+        // gets property types that have actually changed, and the corresponding changes
+        // returns null if no property type has actually changed
+        private Dictionary<int, (ContentVariation FromVariation, ContentVariation ToVariation)> GetPropertyVariationChanges(IEnumerable<PropertyType> propertyTypes)
+        {
+            var propertyTypesL = propertyTypes.ToList();
+
+            // select the current variations (before the change) from database
+            var selectCurrentVariations = Sql()
+                .Select<PropertyTypeDto>(x => x.Id, x => x.Variations)
+                .From<PropertyTypeDto>()
+                .WhereIn<PropertyTypeDto>(x => x.Id, propertyTypesL.Select(x => x.Id));
+
+            var oldVariations = Database.Dictionary<int, byte>(selectCurrentVariations);
+
+            // build a dictionary of actual changes
+            Dictionary<int, (ContentVariation, ContentVariation)> changes = null;
+
+            foreach (var propertyType in propertyTypesL)
+            {
+                // new property type, ignore
+                if (!oldVariations.TryGetValue(propertyType.Id, out var oldVariationB))
+                    continue;
+                var oldVariation = (ContentVariation) oldVariationB; // NPoco cannot fetch directly
+
+                // only those property types that *actually* changed
+                var newVariation = propertyType.Variations;
+                if (oldVariation == newVariation)
+                    continue;
+
+                // allocate the dictionary only when needed
+                if (changes == null)
+                    changes = new Dictionary<int, (ContentVariation, ContentVariation)>();
+
+                changes[propertyType.Id] = (oldVariation, newVariation);
+            }
+
+            return changes;
+        }
+
         /// <summary>
         /// Clear any redirects associated with content for a content type
         /// </summary>
@@ -529,28 +633,39 @@ AND umbracoNode.id <> @id",
         }
 
         /// <summary>
-        /// Moves variant data for property type changes
+        /// Gets the default language identifier.
         /// </summary>
-        /// <param name="propertyTypeChanges"></param>
-        private void MoveVariantData(IDictionary<int, (ContentVariation, ContentVariation)> propertyTypeChanges)
+        private int GetDefaultLanguageId()
         {
-            var defaultLangId = Database.First<int>(Sql().Select<LanguageDto>(x => x.Id).From<LanguageDto>().Where<LanguageDto>(x => x.IsDefault));
+            var selectDefaultLanguageId = Sql()
+                .Select<LanguageDto>(x => x.Id)
+                .From<LanguageDto>()
+                .Where<LanguageDto>(x => x.IsDefault);
+
+            return Database.First<int>(selectDefaultLanguageId);
+        }
+
+        /// <summary>
+        /// Moves variant data for property type variation changes.
+        /// </summary>
+        private void MovePropertyTypeVariantData(IDictionary<int, (ContentVariation FromVariation, ContentVariation ToVariation)> propertyTypeChanges, IEnumerable<IContentTypeComposition> impacted)
+        {
+            var defaultLanguageId = GetDefaultLanguageId();
+            var impactedL = impacted.Select(x => x.Id).ToList();
 
             //Group by the "To" variation so we can bulk update in the correct batches
-            foreach(var g in propertyTypeChanges.GroupBy(x => x.Value.Item2))
+            foreach(var grouping in propertyTypeChanges.GroupBy(x => x.Value.ToVariation))
             {
-                var propertyTypeIds = g.Select(s => s.Key).ToList();
+                var propertyTypeIds = grouping.Select(x => x.Key).ToList();
+                var toVariation = grouping.Key;
 
-                //the ContentVariation that the data is moving "To"
-                var toVariantType = g.Key;
-
-                switch(toVariantType)
+                switch (toVariation)
                 {
                     case ContentVariation.Culture:
-                        MovePropertyDataToVariantCulture(defaultLangId, propertyTypeIds: propertyTypeIds);
+                        CopyPropertyData(null, defaultLanguageId, propertyTypeIds, impactedL);
                         break;
                     case ContentVariation.Nothing:
-                        MovePropertyDataToVariantNothing(defaultLangId, propertyTypeIds: propertyTypeIds);
+                        CopyPropertyData(defaultLanguageId, null, propertyTypeIds, impactedL);
                         break;
                     case ContentVariation.CultureAndSegment:
                     case ContentVariation.Segment:
@@ -561,24 +676,17 @@ AND umbracoNode.id <> @id",
         }
 
         /// <summary>
-        /// Moves variant data for a content type variation change
+        /// Moves variant data for a content type variation change.
         /// </summary>
-        /// <param name="contentType"></param>
-        /// <param name="from"></param>
-        /// <param name="to"></param>
-        private void MoveVariantData(IContentTypeComposition contentType, ContentVariation from, ContentVariation to)
+        private void MoveContentTypeVariantData(IContentTypeComposition contentType, ContentVariation fromVariation, ContentVariation toVariation)
         {
-            var defaultLangId = Database.First<int>(Sql().Select<LanguageDto>(x => x.Id).From<LanguageDto>().Where<LanguageDto>(x => x.IsDefault));
+            var defaultLanguageId = GetDefaultLanguageId();
 
-            var sqlPropertyTypeIds = Sql().Select<PropertyTypeDto>(x => x.Id).From<PropertyTypeDto>().Where<PropertyTypeDto>(x => x.ContentTypeId == contentType.Id);
-            switch (to)
+            switch (toVariation)
             {
                 case ContentVariation.Culture:
-                    //move the property data
 
-                    MovePropertyDataToVariantCulture(defaultLangId, sqlPropertyTypeIds: sqlPropertyTypeIds);
-
-                    //now we need to move the names
+                    //move the names
                     //first clear out any existing names that might already exists under the default lang
                     //there's 2x tables to update
 
@@ -588,10 +696,11 @@ AND umbracoNode.id <> @id",
                         .InnerJoin<ContentVersionDto>().On<ContentVersionDto, ContentVersionCultureVariationDto>(x => x.Id, x => x.VersionId)
                         .InnerJoin<ContentDto>().On<ContentDto, ContentVersionDto>(x => x.NodeId, x => x.NodeId)
                         .Where<ContentDto>(x => x.ContentTypeId == contentType.Id)
-                        .Where<ContentVersionCultureVariationDto>(x => x.LanguageId == defaultLangId);
+                        .Where<ContentVersionCultureVariationDto>(x => x.LanguageId == defaultLanguageId);
                     var sqlDelete = Sql()
                         .Delete<ContentVersionCultureVariationDto>()
                         .WhereIn<ContentVersionCultureVariationDto>(x => x.Id, sqlSelect);
+
                     Database.Execute(sqlDelete);
 
                     //clear out the documentCultureVariation table
@@ -599,10 +708,11 @@ AND umbracoNode.id <> @id",
                         .From<DocumentCultureVariationDto>()
                         .InnerJoin<ContentDto>().On<ContentDto, DocumentCultureVariationDto>(x => x.NodeId, x => x.NodeId)
                         .Where<ContentDto>(x => x.ContentTypeId == contentType.Id)
-                        .Where<DocumentCultureVariationDto>(x => x.LanguageId == defaultLangId);
+                        .Where<DocumentCultureVariationDto>(x => x.LanguageId == defaultLanguageId);
                     sqlDelete = Sql()
                         .Delete<DocumentCultureVariationDto>()
                         .WhereIn<DocumentCultureVariationDto>(x => x.Id, sqlSelect);
+
                     Database.Execute(sqlDelete);
 
                     //now we need to insert names into these 2 tables based on the invariant data
@@ -610,32 +720,31 @@ AND umbracoNode.id <> @id",
                     //insert rows into the versionCultureVariationDto table based on the data from contentVersionDto for the default lang
                     var cols = Sql().Columns<ContentVersionCultureVariationDto>(x => x.VersionId, x => x.Name, x => x.UpdateUserId, x => x.UpdateDate, x => x.LanguageId);
                     sqlSelect = Sql().Select<ContentVersionDto>(x => x.Id, x => x.Text, x => x.UserId, x => x.VersionDate)
-                        .Append($", {defaultLangId}") //default language ID
+                        .Append($", {defaultLanguageId}") //default language ID
                         .From<ContentVersionDto>()
                         .InnerJoin<ContentDto>().On<ContentDto, ContentVersionDto>(x => x.NodeId, x => x.NodeId)
                         .Where<ContentDto>(x => x.ContentTypeId == contentType.Id);
                     var sqlInsert = Sql($"INSERT INTO {ContentVersionCultureVariationDto.TableName} ({cols})").Append(sqlSelect);
+
                     Database.Execute(sqlInsert);
 
                     //insert rows into the documentCultureVariation table
                     cols = Sql().Columns<DocumentCultureVariationDto>(x => x.NodeId, x => x.Edited, x => x.Published, x => x.Name, x => x.Available, x => x.LanguageId);
                     sqlSelect = Sql().Select<DocumentDto>(x => x.NodeId, x => x.Edited, x => x.Published)
                         .AndSelect<NodeDto>(x => x.Text)
-                        .Append($", 1, {defaultLangId}") //make Available + default language ID
+                        .Append($", 1, {defaultLanguageId}") //make Available + default language ID
                         .From<DocumentDto>()
                         .InnerJoin<NodeDto>().On<NodeDto, DocumentDto>(x => x.NodeId, x => x.NodeId)
                         .InnerJoin<ContentDto>().On<ContentDto, NodeDto>(x => x.NodeId, x => x.NodeId)
                         .Where<ContentDto>(x => x.ContentTypeId == contentType.Id);
                     sqlInsert = Sql($"INSERT INTO {DocumentCultureVariationDto.TableName} ({cols})").Append(sqlSelect);
+
                     Database.Execute(sqlInsert);
 
                     break;
                 case ContentVariation.Nothing:
-                    //move the property data
 
-                    MovePropertyDataToVariantNothing(defaultLangId, sqlPropertyTypeIds: sqlPropertyTypeIds);
-
-                    //we dont need to move the names! this is because we always keep the invariant names with the name of the default language.
+                    //we don't need to move the names! this is because we always keep the invariant names with the name of the default language.
 
                     //however, if we were to move names, we could do this: BUT this doesn't work with SQLCE, for that we'd have to update row by row :(
                     // if we want these SQL statements back, look into GIT history
@@ -649,73 +758,102 @@ AND umbracoNode.id <> @id",
         }
 
         /// <summary>
-        /// This will move all property data from variant to invariant
+        /// Copies property data from one language to another.
         /// </summary>
-        /// <param name="defaultLangId"></param>
-        /// <param name="propertyTypeIds">Optional list of property type ids of the properties to be updated</param>
-        /// <param name="sqlPropertyTypeIds">Optional SQL statement used for the sub-query to select the properties type ids for the properties to be updated</param>
-        private void MovePropertyDataToVariantNothing(int defaultLangId, IReadOnlyCollection<int> propertyTypeIds = null, Sql<ISqlContext> sqlPropertyTypeIds = null)
+        /// <param name="sourceLanguageId">The source language (can be null ie invariant).</param>
+        /// <param name="targetLanguageId">The target language (can be null ie invariant)</param>
+        /// <param name="propertyTypeIds">The property type identifiers.</param>
+        /// <param name="contentTypeIds">The content type identifiers.</param>
+        private void CopyPropertyData(int? sourceLanguageId, int? targetLanguageId, IReadOnlyCollection<int> propertyTypeIds, IReadOnlyCollection<int> contentTypeIds = null)
         {
-            //first clear out any existing property data that might already exists under the default lang
+            // fixme - should we batch then?
+            var whereInArgsCount = propertyTypeIds.Count + (contentTypeIds?.Count ?? 0);
+            if (whereInArgsCount > 2000)
+                throw new NotSupportedException("Too many property/content types.");
+
+            //first clear out any existing property data that might already exists under the target language
             var sqlDelete = Sql()
-                .Delete<PropertyDataDto>()
-                .Where<PropertyDataDto>(x => x.LanguageId == null);
-            if (sqlPropertyTypeIds != null)
-                sqlDelete.WhereIn<PropertyDataDto>(x => x.PropertyTypeId, sqlPropertyTypeIds);
-            if (propertyTypeIds != null)
-                sqlDelete.WhereIn<PropertyDataDto>(x => x.PropertyTypeId, propertyTypeIds);
+                .Delete<PropertyDataDto>();
+
+            // not ok for SqlCe (no JOIN in DELETE)
+            //if (contentTypeIds != null)
+            //    sqlDelete
+            //        .From<PropertyDataDto>()
+            //        .InnerJoin<ContentVersionDto>().On<PropertyDataDto, ContentVersionDto>((pdata, cversion) => pdata.VersionId == cversion.Id)
+            //        .InnerJoin<ContentDto>().On<ContentVersionDto, ContentDto>((cversion, c) => cversion.NodeId == c.NodeId);
+
+            Sql<ISqlContext> inSql = null;
+            if (contentTypeIds != null)
+            {
+                inSql = Sql()
+                    .Select<ContentVersionDto>(x => x.Id)
+                    .From<ContentVersionDto>()
+                    .InnerJoin<ContentDto>().On<ContentVersionDto, ContentDto>((cversion, c) => cversion.NodeId == c.NodeId)
+                    .WhereIn<ContentDto>(x => x.ContentTypeId, contentTypeIds);
+                sqlDelete.WhereIn<PropertyDataDto>(x => x.VersionId, inSql);
+            }
+
+            // NPoco cannot turn the clause into IS NULL with a nullable parameter - deal with it
+            if (targetLanguageId == null)
+                sqlDelete.Where<PropertyDataDto>(x => x.LanguageId == null);
+            else
+                sqlDelete.Where<PropertyDataDto>(x => x.LanguageId == targetLanguageId);
+
+            sqlDelete
+                .WhereIn<PropertyDataDto>(x => x.PropertyTypeId, propertyTypeIds);
+
+            // see note above, not ok for SqlCe
+            //if (contentTypeIds != null)
+            //    sqlDelete
+            //        .WhereIn<ContentDto>(x => x.ContentTypeId, contentTypeIds);
 
             Database.Execute(sqlDelete);
 
-            //now insert all property data into the default language that exists under the invariant lang
+            //now insert all property data into the target language that exists under the source language
+            var targetLanguageIdS = targetLanguageId.HasValue ? targetLanguageId.ToString() : "NULL";
             var cols = Sql().Columns<PropertyDataDto>(x => x.VersionId, x => x.PropertyTypeId, x => x.Segment, x => x.IntegerValue, x => x.DecimalValue, x => x.DateValue, x => x.VarcharValue, x => x.TextValue, x => x.LanguageId);
             var sqlSelectData = Sql().Select<PropertyDataDto>(x => x.VersionId, x => x.PropertyTypeId, x => x.Segment, x => x.IntegerValue, x => x.DecimalValue, x => x.DateValue, x => x.VarcharValue, x => x.TextValue)
-                        .Append(", NULL") //null language ID
-                        .From<PropertyDataDto>()
-                        .Where<PropertyDataDto>(x => x.LanguageId == defaultLangId);
-            if (sqlPropertyTypeIds != null)
-                sqlSelectData.WhereIn<PropertyDataDto>(x => x.PropertyTypeId, sqlPropertyTypeIds);
-            if (propertyTypeIds != null)
-                sqlSelectData.WhereIn<PropertyDataDto>(x => x.PropertyTypeId, propertyTypeIds);
+                .Append(", " + targetLanguageIdS) //default language ID
+                .From<PropertyDataDto>();
+
+            if (contentTypeIds != null)
+                sqlSelectData
+                    .InnerJoin<ContentVersionDto>().On<PropertyDataDto, ContentVersionDto>((pdata, cversion) => pdata.VersionId == cversion.Id)
+                    .InnerJoin<ContentDto>().On<ContentVersionDto, ContentDto>((cversion, c) => cversion.NodeId == c.NodeId);
+
+            // NPoco cannot turn the clause into IS NULL with a nullable parameter - deal with it
+            if (sourceLanguageId == null)
+                sqlSelectData.Where<PropertyDataDto>(x => x.LanguageId == null);
+            else
+                sqlSelectData.Where<PropertyDataDto>(x => x.LanguageId == sourceLanguageId);
+
+            sqlSelectData
+                .WhereIn<PropertyDataDto>(x => x.PropertyTypeId, propertyTypeIds);
+
+            if (contentTypeIds != null)
+                sqlSelectData
+                    .WhereIn<ContentDto>(x => x.ContentTypeId, contentTypeIds);
 
             var sqlInsert = Sql($"INSERT INTO {PropertyDataDto.TableName} ({cols})").Append(sqlSelectData);
 
             Database.Execute(sqlInsert);
-        }
 
-        /// <summary>
-        /// This will move all property data from invariant to variant
-        /// </summary>
-        /// <param name="defaultLangId"></param>
-        /// <param name="propertyTypeIds">Optional list of property type ids of the properties to be updated</param>
-        /// <param name="sqlPropertyTypeIds">Optional SQL statement used for the sub-query to select the properties type ids for the properties to be updated</param>
-        private void MovePropertyDataToVariantCulture(int defaultLangId, IReadOnlyCollection<int> propertyTypeIds = null, Sql<ISqlContext> sqlPropertyTypeIds = null)
-        {
-            //first clear out any existing property data that might already exists under the default lang
-            var sqlDelete = Sql()
-                .Delete<PropertyDataDto>()                
-                .Where<PropertyDataDto>(x => x.LanguageId == defaultLangId);
-            if (sqlPropertyTypeIds != null)
-                sqlDelete.WhereIn<PropertyDataDto>(x => x.PropertyTypeId, sqlPropertyTypeIds);
-            if (propertyTypeIds != null)
-                sqlDelete.WhereIn<PropertyDataDto>(x => x.PropertyTypeId, propertyTypeIds);
+            // when copying from Culture, keep the original values around in case we want to go back
+            // when copying from Nothing, kill the original values, we don't want them around
+            if (sourceLanguageId == null)
+            {
+                sqlDelete = Sql()
+                    .Delete<PropertyDataDto>();
 
-            Database.Execute(sqlDelete);
+                if (contentTypeIds != null)
+                    sqlDelete.WhereIn<PropertyDataDto>(x => x.VersionId, inSql);
 
-            //now insert all property data into the default language that exists under the invariant lang
-            var cols = Sql().Columns<PropertyDataDto>(x => x.VersionId, x => x.PropertyTypeId, x => x.Segment, x => x.IntegerValue, x => x.DecimalValue, x => x.DateValue, x => x.VarcharValue, x => x.TextValue, x => x.LanguageId);
-            var sqlSelectData = Sql().Select<PropertyDataDto>(x => x.VersionId, x => x.PropertyTypeId, x => x.Segment, x => x.IntegerValue, x => x.DecimalValue, x => x.DateValue, x => x.VarcharValue, x => x.TextValue)
-                        .Append($", {defaultLangId}") //default language ID
-                        .From<PropertyDataDto>()
-                        .Where<PropertyDataDto>(x => x.LanguageId == null);
-            if (sqlPropertyTypeIds != null)
-                sqlSelectData.WhereIn<PropertyDataDto>(x => x.PropertyTypeId, sqlPropertyTypeIds);
-            if (propertyTypeIds != null)
-                sqlSelectData.WhereIn<PropertyDataDto>(x => x.PropertyTypeId, propertyTypeIds);
-            
-            var sqlInsert = Sql($"INSERT INTO {PropertyDataDto.TableName} ({cols})").Append(sqlSelectData);
+                sqlDelete
+                    .Where<PropertyDataDto>(x => x.LanguageId == null)
+                    .WhereIn<PropertyDataDto>(x => x.PropertyTypeId, propertyTypeIds);
 
-            Database.Execute(sqlInsert);
+                Database.Execute(sqlDelete);
+            }
         }
 
         private void DeletePropertyType(int contentTypeId, int propertyTypeId)
@@ -851,24 +989,6 @@ AND umbracoNode.id <> @id",
             }
         }
 
-        /// <inheritdoc />
-        public IEnumerable<TEntity> GetTypesDirectlyComposedOf(int id)
-        {
-            //fixme - this will probably be more efficient to simply load all content types and do the calculation, see GetWhereCompositionIsUsedInContentTypes
-
-            var sql = Sql()
-                .SelectAll()
-                .From<NodeDto>()
-                .InnerJoin<ContentType2ContentTypeDto>()
-                .On<NodeDto, ContentType2ContentTypeDto>(left => left.NodeId, right => right.ChildId)
-                .Where<NodeDto>(x => x.NodeObjectType == NodeObjectTypeId)
-                .Where<ContentType2ContentTypeDto>(x => x.ParentId == id);
-            var dtos = Database.Fetch<NodeDto>(sql);
-            return dtos.Any()
-                ? GetMany(dtos.DistinctBy(x => x.NodeId).Select(x => x.NodeId).ToArray())
-                : Enumerable.Empty<TEntity>();
-        }
-
         internal static class ContentTypeQueryMapper
         {
             public class AssociatedTemplate

src/Umbraco.Core/Security/AuthenticationExtensions.cs

@@ -1,15 +1,10 @@
 using System;
 using System.Collections.Concurrent;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Globalization;
 using System.Globalization;
 using System.Linq;
 using System.Security.Claims;
 using System.Security.Principal;
-using System.Text;
 using System.Threading;
-using System.Threading.Tasks;
 
 namespace Umbraco.Core.Security
 {

src/Umbraco.Core/Services/ContentTypeServiceExtensions.cs

@@ -30,12 +30,12 @@ namespace Umbraco.Core.Services
             string[] filterPropertyTypes = null)
         {
             filterContentTypes = filterContentTypes == null
-                ? new string[] { }
-                : filterContentTypes.Where(x => x.IsNullOrWhiteSpace() == false).ToArray();
+                ? Array.Empty<string>()
+                : filterContentTypes.Where(x => !x.IsNullOrWhiteSpace()).ToArray();
 
             filterPropertyTypes = filterPropertyTypes == null
-                ? new string[] {}
-                : filterPropertyTypes.Where(x => x.IsNullOrWhiteSpace() == false).ToArray();
+                ? Array.Empty<string>()
+                : filterPropertyTypes.Where(x => !x.IsNullOrWhiteSpace()).ToArray();
 
             //create the full list of property types to use as the filter
             //this is the combination of all property type aliases found in the content types passed in for the filter
@@ -47,7 +47,7 @@ namespace Umbraco.Core.Services
                     .Union(filterPropertyTypes)
                     .ToArray();
 
-            var sourceId = source != null ? source.Id : 0;
+            var sourceId = source?.Id ?? 0;
 
             // find out if any content type uses this content type
             var isUsing = allContentTypes.Where(x => x.ContentTypeComposition.Any(y => y.Id == sourceId)).ToArray();
@@ -161,6 +161,5 @@ namespace Umbraco.Core.Services
 
             return all;
         }
-
     }
 }

src/Umbraco.Core/Services/IContentService.cs

@@ -368,6 +368,11 @@ namespace Umbraco.Core.Services
         /// <para>A publishing document is a document with values that are being published, i.e.
         /// that have been published or cleared via <see cref="IContent.PublishCulture"/> and
         /// <see cref="IContent.UnpublishCulture"/>.</para>
+        /// <para>When one needs to publish or unpublish a single culture, or all cultures, using <see cref="SaveAndPublish"/>
+        /// and <see cref="Unpublish"/> is the way to go. But if one needs to, say, publish two cultures and unpublish a third
+        /// one, in one go, then one needs to invoke <see cref="IContent.PublishCulture"/> and <see cref="IContent.UnpublishCulture"/>
+        /// on the content itself - this prepares the content, but does not commit anything - and then, invoke
+        /// <see cref="SavePublishing"/> to actually commit the changes to the database.</para>
         /// <para>The document is *always* saved, even when publishing fails.</para>
         /// </remarks>
         PublishResult SavePublishing(IContent content, int userId = 0, bool raiseEvents = true);
@@ -375,11 +380,30 @@ namespace Umbraco.Core.Services
         /// <summary>
         /// Saves and publishes a document branch.
         /// </summary>
+        /// <remarks>
+        /// <para>Unless specified, all cultures are re-published. Otherwise, one culture can be specified. To act on more
+        /// that one culture, see the other overload of this method.</para>
+        /// <para>The <paramref name="force"/> parameter determines which documents are published. When <c>false</c>,
+        /// only those documents that are already published, are republished. When <c>true</c>, all documents are
+        /// published.</para>
+        /// </remarks>
         IEnumerable<PublishResult> SaveAndPublishBranch(IContent content, bool force, string culture = "*", int userId = 0);
 
         /// <summary>
         /// Saves and publishes a document branch.
         /// </summary>
+        /// <remarks>
+        /// <para>The <paramref name="force"/> parameter determines which documents are published. When <c>false</c>,
+        /// only those documents that are already published, are republished. When <c>true</c>, all documents are
+        /// published.</para>
+        /// <para>The <paramref name="editing"/> parameter is a function which determines whether a document has
+        /// values to publish (else there is no need to publish it). If one wants to publish only a selection of
+        /// cultures, one may want to check that only properties for these cultures have changed. Otherwise, other
+        /// cultures may trigger an unwanted republish.</para>
+        /// <para>The <paramref name="publishCultures"/> parameter is a function to execute to publish cultures, on
+        /// each document. It can publish all, one, or a selection of cultures. It returns a boolean indicating
+        /// whether the cultures could be published.</para>
+        /// </remarks>
         IEnumerable<PublishResult> SaveAndPublishBranch(IContent content, bool force, Func<IContent, bool> editing, Func<IContent, bool> publishCultures, int userId = 0);
 
         /// <summary>

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

@@ -1272,12 +1272,49 @@ namespace Umbraco.Core.Services.Implement
 
             bool IsEditing(IContent c, string l)
                 => c.PublishName != c.Name ||
-                   c.PublishedCultures.Any(x => c.GetCultureName(x) != c.GetPublishName(x)) ||
-                   c.Properties.Any(x => x.Values.Where(y => culture == "*" || y.Culture == l).Any(y => !y.EditedValue.Equals(y.PublishedValue)));
+                   c.PublishedCultures.Where(x => x.InvariantEquals(l)).Any(x => c.GetCultureName(x) != c.GetPublishName(x)) ||
+                   c.Properties.Any(x => x.Values.Where(y => culture == "*" || y.Culture.InvariantEquals(l)).Any(y => !y.EditedValue.Equals(y.PublishedValue)));
 
             return SaveAndPublishBranch(content, force, document => IsEditing(document, culture), document => document.PublishCulture(culture), userId);
         }
 
+        // fixme - make this public once we know it works + document
+        private IEnumerable<PublishResult> SaveAndPublishBranch(IContent content, bool force, string[] cultures, int userId = 0)
+        {
+            // note: EditedValue and PublishedValue are objects here, so it is important to .Equals()
+            // and not to == them, else we would be comparing references, and that is a bad thing
+
+            cultures = cultures ?? Array.Empty<string>();
+
+            // determines whether the document is edited, and thus needs to be published,
+            // for the specified cultures (it may be edited for other cultures and that
+            // should not trigger a publish).
+            bool IsEdited(IContent c)
+            {
+                if (cultures.Length == 0)
+                {
+                    // nothing = everything
+                    return c.PublishName != c.Name ||
+                           c.PublishedCultures.Any(x => c.GetCultureName(x) != c.GetPublishName(x)) ||
+                           c.Properties.Any(x => x.Values.Any(y => !y.EditedValue.Equals(y.PublishedValue)));
+                }
+
+                return c.PublishName != c.Name ||
+                       c.PublishedCultures.Where(x => cultures.Contains(x, StringComparer.InvariantCultureIgnoreCase)).Any(x => c.GetCultureName(x) != c.GetPublishName(x)) ||
+                       c.Properties.Any(x => x.Values.Where(y => cultures.Contains(y.Culture, StringComparer.InvariantCultureIgnoreCase)).Any(y => !y.EditedValue.Equals(y.PublishedValue)));
+            }
+
+            // publish the specified cultures
+            bool PublishCultures(IContent c)
+            {
+                return cultures.Length == 0
+                    ? c.PublishCulture() // nothing = everything
+                    : cultures.All(c.PublishCulture);
+            }
+
+            return SaveAndPublishBranch(content, force, IsEdited, PublishCultures, userId);
+        }
+
         /// <inheritdoc />
         public IEnumerable<PublishResult> SaveAndPublishBranch(IContent document, bool force,
             Func<IContent, bool> editing, Func<IContent, bool> publishCultures, int userId = 0)

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

@@ -344,37 +344,18 @@ namespace Umbraco.Core.Services.Implement
             }
         }
 
+        public IEnumerable<TItem> GetComposedOf(int id, IEnumerable<TItem> all)
+        {
+            return all.Where(x => x.ContentTypeComposition.Any(y => y.Id == id));
+
+        }
+
         public IEnumerable<TItem> GetComposedOf(int id)
         {
-            //fixme: this is essentially the same as ContentTypeServiceExtensions.GetWhereCompositionIsUsedInContentTypes which loads
-            // all content types to figure this out, this instead makes quite a few queries so should be replaced
-
-            using (var scope = ScopeProvider.CreateScope(autoComplete: true))
-            {
-                scope.ReadLock(ReadLockIds);
-
-                // hash set handles duplicates
-                var composed = new HashSet<TItem>(new DelegateEqualityComparer<TItem>(
-                    (x, y) => x.Id == y.Id,
-                    x => x.Id.GetHashCode()));
-
-                var ids = new Stack<int>();
-                ids.Push(id);
-
-                while (ids.Count > 0)
-                {
-                    var i = ids.Pop();
-                    var result = Repository.GetTypesDirectlyComposedOf(i).ToArray();
-
-                    foreach (var c in result)
-                    {
-                        composed.Add(c);
-                        ids.Push(c.Id);
-                    }
-                }
-
-                return composed.ToArray();
-            }
+            // GetAll is cheap, repository has a full dataset cache policy
+            // fixme - still, because it uses the cache, race conditions!
+            var allContentTypes = GetAll(Array.Empty<int>());
+            return GetComposedOf(id, allContentTypes);
         }
 
         public int Count()