Merge v8/dev 20-10-2021

src/Umbraco.Core/Exceptions/InvalidCompositionException.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Runtime.Serialization;
 using Umbraco.Extensions;
+using System.Text;
 
 namespace Umbraco.Cms.Core.Exceptions
 {
@@ -86,18 +87,28 @@ public InvalidCompositionException(string contentTypeAlias, string addedComposit
 
         private static string FormatMessage(string contentTypeAlias, string addedCompositionAlias, string[] propertyTypeAliases, string[] propertyGroupAliases)
         {
-            // TODO Add property group aliases to message
-            return addedCompositionAlias.IsNullOrWhiteSpace()
-                    ? string.Format(
-                        "ContentType with alias '{0}' has an invalid composition " +
-                        "and there was a conflict on the following PropertyTypes: '{1}'. " +
-                        "PropertyTypes must have a unique alias across all Compositions in order to compose a valid ContentType Composition.",
-                        contentTypeAlias, string.Join(", ", propertyTypeAliases))
-                    : string.Format(
-                        "ContentType with alias '{0}' was added as a Composition to ContentType with alias '{1}', " +
-                        "but there was a conflict on the following PropertyTypes: '{2}'. " +
-                        "PropertyTypes must have a unique alias across all Compositions in order to compose a valid ContentType Composition.",
-                        addedCompositionAlias, contentTypeAlias, string.Join(", ", propertyTypeAliases));
+            var sb = new StringBuilder();
+
+            if (addedCompositionAlias.IsNullOrWhiteSpace())
+            {
+                sb.AppendFormat("Content type with alias '{0}' has an invalid composition.", contentTypeAlias);
+            }
+            else
+            {
+                sb.AppendFormat("Content type with alias '{0}' was added as a composition to content type with alias '{1}', but there was a conflict.", addedCompositionAlias, contentTypeAlias);
+            }
+
+            if (propertyTypeAliases.Length > 0)
+            {
+                sb.AppendFormat(" Property types must have a unique alias across all compositions, these aliases are duplicate: {0}.", string.Join(", ", propertyTypeAliases));
+            }
+
+            if (propertyGroupAliases.Length > 0)
+            {
+                sb.AppendFormat(" Property groups with the same alias must also have the same type across all compositions, these aliases have different types: {0}.", string.Join(", ", propertyGroupAliases));
+            }
+
+            return sb.ToString();
         }
 
         /// <summary>

src/Umbraco.Core/Strings/DefaultUrlSegmentProvider.cs

@@ -32,7 +32,13 @@ private static string GetUrlSegmentSource(IContentBase content, string culture)
             if (content.HasProperty(Constants.Conventions.Content.UrlName))
                 source = (content.GetValue<string>(Constants.Conventions.Content.UrlName, culture) ?? string.Empty).Trim();
             if (string.IsNullOrWhiteSpace(source))
-                source = content.GetCultureName(culture);
+            {
+                // If the name of a node has been updated, but it has not been published, the url should use the published name, not the current node name
+                // If this node has never been published (GetPublishName is null), use the unpublished name
+                source = (content is IContent document) && document.Edited && document.GetPublishName(culture) != null
+                    ? document.GetPublishName(culture)
+                    : content.GetCultureName(culture);
+            }
             return source;
         }
     }

src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentRepository.cs

@@ -673,6 +673,19 @@ protected override void PersistUpdatedItem(IContent entity)
                     edited = true;
                 }
 
+                // To establish the new value of "edited" we compare all properties publishedValue to editedValue and look
+                // for differences.
+                //
+                // If we SaveAndPublish but the publish fails (e.g. already scheduled for release)
+                // we have lost the publishedValue on IContent (in memory vs database) so we cannot correctly make that comparison.
+                //
+                // This is a slight change to behaviour, historically a publish, followed by change & save, followed by undo change & save
+                // would change edited back to false.
+                if (!publishing && editedSnapshot)
+                {
+                    edited = true;
+                }
+
                 if (entity.ContentType.VariesByCulture())
                 {
                     // names also impact 'edited'

src/Umbraco.Infrastructure/PropertyEditors/BlockEditorPropertyHandler.cs

@@ -122,7 +122,7 @@ private void RecursePropertyValues(IEnumerable<BlockItemData> blockData, Func<Gu
                             {
                                 json = JToken.Parse(asString);
                             }
-                            catch (Exception e)
+                            catch (Exception)
                             {
                                 // See issue https://github.com/umbraco/Umbraco-CMS/issues/10879
                                 // We are detecting JSON data by seeing if a string is surrounded by [] or {}

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

@@ -134,6 +134,9 @@ protected void ValidateLocked(TItem compositionContentType)
                     stack.Push(c);
             }
 
+            var duplicatePropertyTypeAliases = new List<string>();
+            var invalidPropertyGroupAliases = new List<string>();
+
             foreach (var dependency in dependencies)
             {
                 if (dependency.Id == compositionContentType.Id)
@@ -143,13 +146,14 @@ protected void ValidateLocked(TItem compositionContentType)
                 if (contentTypeDependency == null)
                     continue;
 
-                var duplicatePropertyTypeAliases = contentTypeDependency.PropertyTypes.Select(x => x.Alias).Intersect(propertyTypeAliases, StringComparer.InvariantCultureIgnoreCase).ToArray();
-                var invalidPropertyGroupAliases = contentTypeDependency.PropertyGroups.Where(x => propertyGroupAliases.TryGetValue(x.Alias, out var type) && type != x.Type).Select(x => x.Alias).ToArray();
+                duplicatePropertyTypeAliases.AddRange(contentTypeDependency.PropertyTypes.Select(x => x.Alias).Intersect(propertyTypeAliases, StringComparer.InvariantCultureIgnoreCase));
+                invalidPropertyGroupAliases.AddRange(contentTypeDependency.PropertyGroups.Where(x => propertyGroupAliases.TryGetValue(x.Alias, out var type) && type != x.Type).Select(x => x.Alias));
+            }
 
-                if (duplicatePropertyTypeAliases.Length == 0 && invalidPropertyGroupAliases.Length == 0)
-                    continue;
+            if (duplicatePropertyTypeAliases.Count > 0 || invalidPropertyGroupAliases.Count > 0)
 
-                throw new InvalidCompositionException(compositionContentType.Alias, null, duplicatePropertyTypeAliases, invalidPropertyGroupAliases);
+            {
+                throw new InvalidCompositionException(compositionContentType.Alias, null, duplicatePropertyTypeAliases.Distinct().ToArray(), invalidPropertyGroupAliases.Distinct().ToArray());
             }
         }
 

src/Umbraco.Web.BackOffice/Controllers/ContentTypeControllerBase.cs

@@ -475,10 +475,12 @@ private TContentTypeDisplay CreateCompositionValidationExceptionIfInvalid<TConte
             var validateAttempt = service.ValidateComposition(composition);
             if (validateAttempt == false)
             {
-                //if it's not successful then we need to return some model state for the property aliases that
-                // are duplicated
-                var invalidPropertyAliases = validateAttempt.Result.Distinct();
-                AddCompositionValidationErrors<TContentTypeSave, TPropertyType>(contentTypeSave, invalidPropertyAliases);
+                // if it's not successful then we need to return some model state for the property type and property group
+                // aliases that are duplicated
+                var duplicatePropertyTypeAliases = validateAttempt.Result.Distinct();
+                var invalidPropertyGroupAliases = (validateAttempt.Exception as InvalidCompositionException)?.PropertyGroupAliases ?? Array.Empty<string>();
+
+                AddCompositionValidationErrors<TContentTypeSave, TPropertyType>(contentTypeSave, duplicatePropertyTypeAliases, invalidPropertyGroupAliases);
 
                 var display = UmbracoMapper.Map<TContentTypeDisplay>(composition);
                 //map the 'save' data on top
@@ -505,22 +507,32 @@ public IContentTypeBaseService<T> GetContentTypeService<T>()
         /// Adds errors to the model state if any invalid aliases are found then throws an error response if there are errors
         /// </summary>
         /// <param name="contentTypeSave"></param>
-        /// <param name="invalidPropertyAliases"></param>
+        /// <param name="duplicatePropertyTypeAliases"></param>
+        /// <param name="invalidPropertyGroupAliases"></param>
         /// <returns></returns>
-        private void AddCompositionValidationErrors<TContentTypeSave, TPropertyType>(TContentTypeSave contentTypeSave, IEnumerable<string> invalidPropertyAliases)
+        private void AddCompositionValidationErrors<TContentTypeSave, TPropertyType>(TContentTypeSave contentTypeSave, IEnumerable<string> duplicatePropertyTypeAliases, IEnumerable<string> invalidPropertyGroupAliases)
             where TContentTypeSave : ContentTypeSave<TPropertyType>
             where TPropertyType : PropertyTypeBasic
         {
-            foreach (var propertyAlias in invalidPropertyAliases)
+            foreach (var propertyTypeAlias in duplicatePropertyTypeAliases)
             {
-                // Find the property relating to these
-                var property = contentTypeSave.Groups.SelectMany(x => x.Properties).Single(x => x.Alias == propertyAlias);
+                // Find the property type relating to these
+                var property = contentTypeSave.Groups.SelectMany(x => x.Properties).Single(x => x.Alias == propertyTypeAlias);
                 var group = contentTypeSave.Groups.Single(x => x.Properties.Contains(property));
                 var propertyIndex = group.Properties.IndexOf(property);
                 var groupIndex = contentTypeSave.Groups.IndexOf(group);
 
                 var key = $"Groups[{groupIndex}].Properties[{propertyIndex}].Alias";
-                ModelState.AddModelError(key, "Duplicate property aliases not allowed between compositions");
+                ModelState.AddModelError(key, "Duplicate property aliases aren't allowed between compositions");
+            }
+
+            foreach (var propertyGroupAlias in invalidPropertyGroupAliases)
+            {
+                // Find the property group relating to these
+                var group = contentTypeSave.Groups.Single(x => x.Alias == propertyGroupAlias);
+                var groupIndex = contentTypeSave.Groups.IndexOf(group);
+                var key = $"Groups[{groupIndex}].Name";
+                ModelState.AddModelError(key, "Different group types aren't allowed between compositions");
             }
         }
 
@@ -552,7 +564,7 @@ private TContentTypeDisplay CreateInvalidCompositionResponseException<TContentTy
             }
             if (invalidCompositionException != null)
             {
-                AddCompositionValidationErrors<TContentTypeSave, TPropertyType>(contentTypeSave, invalidCompositionException.PropertyTypeAliases);
+                AddCompositionValidationErrors<TContentTypeSave, TPropertyType>(contentTypeSave, invalidCompositionException.PropertyTypeAliases, invalidCompositionException.PropertyGroupAliases);
                 return CreateModelStateValidationEror<TContentTypeSave, TContentTypeDisplay>(ctId, contentTypeSave, ct);
             }
             return null;

src/Umbraco.Web.BackOffice/Controllers/EntityController.cs

@@ -120,6 +120,8 @@ public EntityController(
             _appCaches = appCaches ?? throw new ArgumentNullException(nameof(appCaches));
         }
 
+
+
         /// <summary>
         /// Returns an Umbraco alias given a string
         /// </summary>
@@ -288,6 +290,50 @@ public IActionResult GetUrl(Udi id, string culture = "*")
             return GetUrl(intId.Result, entityType, culture);
         }
 
+        /// <summary>
+        /// Get entity URLs by UDIs
+        /// </summary>
+        /// <param name="udis">
+        /// A list of UDIs to lookup items by
+        /// </param>
+        /// <param name="culture">The culture to fetch the URL for</param>
+        /// <returns>Dictionary mapping Udi -> Url</returns>
+        /// <remarks>
+        /// We allow for POST because there could be quite a lot of Ids.
+        /// </remarks>
+        [HttpGet]
+        [HttpPost]
+        public IDictionary<Udi, string> GetUrlsByUdis([FromJsonPath] Udi[] udis, string culture = null)
+        {
+            if (udis == null || udis.Length == 0)
+            {
+                return new Dictionary<Udi, string>();
+            }
+
+            // TODO: PMJ 2021-09-27 - Should GetUrl(Udi) exist as an extension method on UrlProvider/IUrlProvider (in v9)
+            string MediaOrDocumentUrl(Udi udi)
+            {
+                if (udi is not GuidUdi guidUdi)
+                {
+                    return null;
+                }
+
+                return guidUdi.EntityType switch
+                {
+                    Constants.UdiEntityType.Document => _publishedUrlProvider.GetUrl(guidUdi.Guid, culture: culture ?? ClientCulture()),
+                    // NOTE: If culture is passed here we get an empty string rather than a media item URL WAT
+                    Constants.UdiEntityType.Media => _publishedUrlProvider.GetMediaUrl(guidUdi.Guid, culture: null),
+                    _ => null
+                };
+            }
+
+            return udis
+                .Select(udi => new {
+                    Udi = udi,
+                    Url = MediaOrDocumentUrl(udi)
+                }).ToDictionary(x => x.Udi, x => x.Url);
+        }
+
         /// <summary>
         /// Gets the URL of an entity
         /// </summary>

src/Umbraco.Web.BackOffice/Controllers/MemberGroupController.cs

@@ -120,6 +120,18 @@ public MemberGroupDisplay GetEmpty()
             return _umbracoMapper.Map<IMemberGroup, MemberGroupDisplay>(item);
         }
 
+        public bool IsMemberGroupNameUnique(int id, string oldName, string newName)
+        {
+            if (newName == oldName)
+                return true; // name hasn't changed
+
+            var memberGroup = _memberGroupService.GetByName(newName);
+            if (memberGroup == null)
+                return true; // no member group found
+
+            return memberGroup.Id == id;
+        }
+
         public ActionResult<MemberGroupDisplay> PostSave(MemberGroupSave saveModel)
         {
 
@@ -130,16 +142,28 @@ public ActionResult<MemberGroupDisplay> PostSave(MemberGroupSave saveModel)
                 return NotFound();
             }
 
-            memberGroup.Name = saveModel.Name;
-            _memberGroupService.Save(memberGroup);
+            if (IsMemberGroupNameUnique(memberGroup.Id, memberGroup.Name, saveModel.Name))
+            {
+                memberGroup.Name = saveModel.Name;
+                _memberGroupService.Save(memberGroup);
 
-            MemberGroupDisplay display = _umbracoMapper.Map<IMemberGroup, MemberGroupDisplay>(memberGroup);
+                MemberGroupDisplay display = _umbracoMapper.Map<IMemberGroup, MemberGroupDisplay>(memberGroup);
 
-            display.AddSuccessNotification(
-                            _localizedTextService.Localize("speechBubbles","memberGroupSavedHeader"),
-                            string.Empty);
+                display.AddSuccessNotification(
+                    _localizedTextService.Localize("speechBubbles", "memberGroupSavedHeader"),
+                    string.Empty);
 
-            return display;
+                return display;
+            }
+            else
+            {
+                var display = _umbracoMapper.Map<IMemberGroup, MemberGroupDisplay>(memberGroup);
+                display.AddErrorNotification(
+                    _localizedTextService.Localize("speechBubbles", "memberGroupNameDuplicate"),
+                    string.Empty);
+
+                return display;
+            }
         }
     }
 }