yv01p/Umbraco-CMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/netcore/dev' into netcore/netcore

Browse Source 
# Conflicts:
#	src/Umbraco.Web.UI.Client/package-lock.json
#	src/Umbraco.Web.UI.NetCore/Startup.cs
This commit is contained in:
Bjarke Berg
2020-05-18 11:51:55 +02:00
parent c36c2f6a33 cda531e34e
commit 5e131ebafb
44 changed files with 1480 additions and 16216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
src/Umbraco.Web/Editors/ContentController.cs
View File

@@ -34,6 +34,7 @@ using Umbraco.Web.Models.ContentEditing;
using Umbraco.Web.Models.Mapping;
using Umbraco.Web.Mvc;
using Umbraco.Web.Routing;
using Umbraco.Core.Collections;
using Umbraco.Web.WebApi;
using Umbraco.Web.WebApi.Filters;
using Constants = Umbraco.Core.Constants;
@@ -720,12 +721,19 @@ namespace Umbraco.Web.Editors
{
if (variantCount > 1)
{
var cultureErrors = ModelState.GetCulturesWithErrors(Services.LocalizationService, cultureForInvariantErrors);
foreach (var c in contentItem.Variants.Where(x => x.Save && !cultureErrors.Contains(x.Culture)).Select(x => x.Culture).ToArray())
var variantErrors = ModelState.GetVariantsWithErrors(cultureForInvariantErrors);
var validVariants = contentItem.Variants
.Where(x => x.Save && !variantErrors.Contains((x.Culture, x.Segment)))
.Select(x => (culture: x.Culture, segment: x.Segment));
foreach (var (culture, segment) in validVariants)
{
AddSuccessNotification(notifications, c,
var variantName = GetVariantName(culture, segment);
AddSuccessNotification(notifications, culture, segment,
Services.TextService.Localize("speechBubbles/editContentSendToPublish"),
Services.TextService.Localize("speechBubbles/editVariantSendToPublishText", new[] { _allLangs.Value[c].CultureName }));
Services.TextService.Localize("speechBubbles/editVariantSendToPublishText", new[] { variantName }));
}
}
else if (ModelState.IsValid)
@@ -856,7 +864,7 @@ namespace Umbraco.Web.Editors
//if there's more than 1 variant, then we need to add the culture specific error
//messages based on the variants in error so that the messages show in the publish/save dialog
if (variants.Count > 1)
AddCultureValidationError(variant.Culture, "publish/contentPublishedFailedByMissingName");
AddVariantValidationError(variant.Culture, variant.Segment, "publish/contentPublishedFailedByMissingName");
else
return false; //It's invariant and is missing critical data, it cannot be saved
}
@@ -910,18 +918,19 @@ namespace Umbraco.Web.Editors
{
if (variantCount > 1)
{
var cultureErrors = ModelState.GetCulturesWithErrors(Services.LocalizationService, cultureForInvariantErrors);
var variantErrors = ModelState.GetVariantsWithErrors(cultureForInvariantErrors);
var savedWithoutErrors = contentItem.Variants
.Where(x => x.Save && !cultureErrors.Contains(x.Culture) && x.Culture != null)
.Select(x => x.Culture)
.ToArray();
.Where(x => x.Save && !variantErrors.Contains((x.Culture, x.Segment)))
.Select(x => (culture: x.Culture, segment: x.Segment));
foreach (var c in savedWithoutErrors)
foreach (var (culture, segment) in savedWithoutErrors)
{
AddSuccessNotification(notifications, c,
var variantName = GetVariantName(culture, segment);
AddSuccessNotification(notifications, culture, segment,
Services.TextService.Localize("speechBubbles/editContentSavedHeader"),
Services.TextService.Localize(variantSavedLocalizationKey, new[] { _allLangs.Value[c].CultureName }));
Services.TextService.Localize(variantSavedLocalizationKey, new[] { variantName }));
}
}
else if (ModelState.IsValid)
@@ -1054,14 +1063,16 @@ namespace Umbraco.Web.Editors
if (!isPublished && releaseDates.Count == 0)
{
//can't continue, a mandatory variant is not published and not scheduled for publishing
AddCultureValidationError(culture, "speechBubbles/scheduleErrReleaseDate2");
// TODO: Add segment
AddVariantValidationError(culture, null, "speechBubbles/scheduleErrReleaseDate2");
isValid = false;
continue;
}
if (!isPublished && releaseDates.Any(x => nonMandatoryVariantReleaseDates.Any(r => x.Date > r.Date)))
{
//can't continue, a mandatory variant is not published and it's scheduled for publishing after a non-mandatory
AddCultureValidationError(culture, "speechBubbles/scheduleErrReleaseDate3");
// TODO: Add segment
AddVariantValidationError(culture, null, "speechBubbles/scheduleErrReleaseDate3");
isValid = false;
continue;
}
@@ -1075,7 +1086,7 @@ namespace Umbraco.Web.Editors
//1) release date cannot be less than now
if (variant.ReleaseDate.HasValue && variant.ReleaseDate < DateTime.Now)
{
AddCultureValidationError(variant.Culture, "speechBubbles/scheduleErrReleaseDate1");
AddVariantValidationError(variant.Culture, variant.Segment, "speechBubbles/scheduleErrReleaseDate1");
isValid = false;
continue;
}
@@ -1083,7 +1094,7 @@ namespace Umbraco.Web.Editors
//2) expire date cannot be less than now
if (variant.ExpireDate.HasValue && variant.ExpireDate < DateTime.Now)
{
AddCultureValidationError(variant.Culture, "speechBubbles/scheduleErrExpireDate1");
AddVariantValidationError(variant.Culture, variant.Segment, "speechBubbles/scheduleErrExpireDate1");
isValid = false;
continue;
}
@@ -1091,7 +1102,7 @@ namespace Umbraco.Web.Editors
//3) expire date cannot be less than release date
if (variant.ExpireDate.HasValue && variant.ReleaseDate.HasValue && variant.ExpireDate <= variant.ReleaseDate)
{
AddCultureValidationError(variant.Culture, "speechBubbles/scheduleErrExpireDate2");
AddVariantValidationError(variant.Culture, variant.Segment, "speechBubbles/scheduleErrExpireDate2");
isValid = false;
continue;
}
@@ -1116,12 +1127,13 @@ namespace Umbraco.Web.Editors
/// global notifications will be shown if all variant processing is successful and the save/publish dialog is closed, otherwise
/// variant specific notifications are used to show success messages in the save/publish dialog.
/// </remarks>
private static void AddSuccessNotification(IDictionary<string, SimpleNotificationModel> notifications, string culture, string header, string msg)
private static void AddSuccessNotification(IDictionary<string, SimpleNotificationModel> notifications, string culture, string segment, string header, string msg)
{
//add the global notification (which will display globally if all variants are successfully processed)
notifications[string.Empty].AddSuccessNotification(header, msg);
//add the variant specific notification (which will display in the dialog if all variants are not successfully processed)
notifications.GetOrCreate(culture).AddSuccessNotification(header, msg);
var key = culture + "_" + segment;
notifications.GetOrCreate(key).AddSuccessNotification(header, msg);
}
/// <summary>
@@ -1171,17 +1183,16 @@ namespace Umbraco.Web.Editors
return publishStatus;
}
//All variants in this collection should have a culture if we get here! but we'll double check and filter here
var cultureVariants = contentItem.Variants.Where(x => !x.Culture.IsNullOrWhiteSpace()).ToList();
var mandatoryCultures = _allLangs.Value.Values.Where(x => x.IsMandatory).Select(x => x.IsoCode).ToList();
var cultureErrors = ModelState.GetCulturesWithErrors(Services.LocalizationService, cultureForInvariantErrors);
var variantErrors = ModelState.GetVariantsWithErrors(cultureForInvariantErrors);
var variants = contentItem.Variants.ToList();
//validate if we can publish based on the mandatory language requirements
var canPublish = ValidatePublishingMandatoryLanguages(
cultureErrors,
contentItem, cultureVariants, mandatoryCultures,
variantErrors,
contentItem, variants, mandatoryCultures,
mandatoryVariant => mandatoryVariant.Publish);
//Now check if there are validation errors on each variant.
@@ -1191,11 +1202,11 @@ namespace Umbraco.Web.Editors
foreach (var variant in contentItem.Variants)
{
if (cultureErrors.Contains(variant.Culture))
if (variantErrors.Contains((variant.Culture, variant.Segment)))
variant.Publish = false;
}
var culturesToPublish = cultureVariants.Where(x => x.Publish).Select(x => x.Culture).ToArray();
var culturesToPublish = variants.Where(x => x.Publish).Select(x => x.Culture).ToArray();
if (canPublish)
{
@@ -1243,17 +1254,16 @@ namespace Umbraco.Web.Editors
return publishStatus;
}
//All variants in this collection should have a culture if we get here! but we'll double check and filter here
var cultureVariants = contentItem.Variants.Where(x => !x.Culture.IsNullOrWhiteSpace()).ToList();
var mandatoryCultures = _allLangs.Value.Values.Where(x => x.IsMandatory).Select(x => x.IsoCode).ToList();
var cultureErrors = ModelState.GetCulturesWithErrors(Services.LocalizationService, cultureForInvariantErrors);
var variantErrors = ModelState.GetVariantsWithErrors(cultureForInvariantErrors);
var variants = contentItem.Variants.ToList();
//validate if we can publish based on the mandatory languages selected
var canPublish = ValidatePublishingMandatoryLanguages(
cultureErrors,
contentItem, cultureVariants, mandatoryCultures,
variantErrors,
contentItem, variants, mandatoryCultures,
mandatoryVariant => mandatoryVariant.Publish);
//if none are published and there are validation errors for mandatory cultures, then we can't publish anything
@@ -1265,19 +1275,19 @@ namespace Umbraco.Web.Editors
//It is a requirement that this is performed AFTER ValidatePublishingMandatoryLanguages.
foreach (var variant in contentItem.Variants)
{
if (cultureErrors.Contains(variant.Culture))
if (variantErrors.Contains((variant.Culture, variant.Segment)))
variant.Publish = false;
}
//At this stage all variants might have failed validation which means there are no cultures flagged for publishing!
var culturesToPublish = cultureVariants.Where(x => x.Publish).Select(x => x.Culture).ToArray();
var culturesToPublish = variants.Where(x => x.Publish).Select(x => x.Culture).ToArray();
canPublish = canPublish && culturesToPublish.Length > 0;
if (canPublish)
{
//try to publish all the values on the model - this will generally only fail if someone is tampering with the request
//since there's no reason variant rules would be violated in normal cases.
canPublish = PublishCulture(contentItem.PersistedContent, cultureVariants, defaultCulture);
canPublish = PublishCulture(contentItem.PersistedContent, variants, defaultCulture);
}
if (canPublish)
@@ -1302,16 +1312,16 @@ namespace Umbraco.Web.Editors
/// <summary>
/// Validate if publishing is possible based on the mandatory language requirements
/// </summary>
/// <param name="culturesWithValidationErrors"></param>
/// <param name="variantsWithValidationErrors"></param>
/// <param name="contentItem"></param>
/// <param name="cultureVariants"></param>
/// <param name="variants"></param>
/// <param name="mandatoryCultures"></param>
/// <param name="publishingCheck"></param>
/// <returns></returns>
private bool ValidatePublishingMandatoryLanguages(
IReadOnlyCollection<string> culturesWithValidationErrors,
IReadOnlyCollection<(string culture, string segment)> variantsWithValidationErrors,
ContentItemSave contentItem,
IReadOnlyCollection<ContentVariantSave> cultureVariants,
IReadOnlyCollection<ContentVariantSave> variants,
IReadOnlyList<string> mandatoryCultures,
Func<ContentVariantSave, bool> publishingCheck)
{
@@ -1322,11 +1332,11 @@ namespace Umbraco.Web.Editors
{
//Check if a mandatory language is missing from being published
var mandatoryVariant = cultureVariants.First(x => x.Culture.InvariantEquals(culture));
var mandatoryVariant = variants.First(x => x.Culture.InvariantEquals(culture));
var isPublished = contentItem.PersistedContent.Published && contentItem.PersistedContent.IsCulturePublished(culture);
var isPublishing = isPublished || publishingCheck(mandatoryVariant);
var isValid = !culturesWithValidationErrors.InvariantContains(culture);
var isValid = !variantsWithValidationErrors.Select(v => v.culture).InvariantContains(culture);
result.Add((mandatoryVariant, isPublished || isPublishing, isValid));
}
@@ -1341,19 +1351,19 @@ namespace Umbraco.Web.Editors
if (r.publishing && !r.isValid)
{
//flagged for publishing but the mandatory culture is invalid
AddCultureValidationError(r.model.Culture, "publish/contentPublishedFailedReqCultureValidationError");
AddVariantValidationError(r.model.Culture, r.model.Segment, "publish/contentPublishedFailedReqCultureValidationError");
canPublish = false;
}
else if (r.publishing && r.isValid && firstInvalidMandatoryCulture != null)
{
//in this case this culture also cannot be published because another mandatory culture is invalid
AddCultureValidationError(r.model.Culture, "publish/contentPublishedFailedReqCultureValidationError", firstInvalidMandatoryCulture);
AddVariantValidationError(r.model.Culture, r.model.Segment, "publish/contentPublishedFailedReqCultureValidationError", firstInvalidMandatoryCulture);
canPublish = false;
}
else if (!r.publishing)
{
//cannot continue publishing since a required culture that is not currently being published isn't published
AddCultureValidationError(r.model.Culture, "speechBubbles/contentReqCulturePublishError");
AddVariantValidationError(r.model.Culture, r.model.Segment, "speechBubbles/contentReqCulturePublishError");
canPublish = false;
}
}
@@ -1378,7 +1388,7 @@ namespace Umbraco.Web.Editors
var valid = persistentContent.PublishCulture(CultureImpact.Explicit(variant.Culture, defaultCulture.InvariantEquals(variant.Culture)));
if (!valid)
{
AddCultureValidationError(variant.Culture, "speechBubbles/contentCultureValidationError");
AddVariantValidationError(variant.Culture, variant.Segment, "speechBubbles/contentCultureValidationError");
return false;
}
}
@@ -1390,14 +1400,40 @@ namespace Umbraco.Web.Editors
/// Adds a generic culture error for use in displaying the culture validation error in the save/publish/etc... dialogs
/// </summary>
/// <param name="culture">Culture to assign the error to</param>
/// <param name="segment">Segment to assign the error to</param>
/// <param name="localizationKey"></param>
/// <param name="cultureToken">
/// The culture used in the localization message, null by default which means <see cref="culture"/> will be used.
/// </param>
private void AddCultureValidationError(string culture, string localizationKey, string cultureToken = null)
private void AddVariantValidationError(string culture, string segment, string localizationKey, string cultureToken = null)
{
var errMsg = Services.TextService.Localize(localizationKey, new[] { cultureToken == null ? _allLangs.Value[culture].CultureName : _allLangs.Value[cultureToken].CultureName });
ModelState.AddCultureValidationError(culture, errMsg);
var cultureToUse = cultureToken ?? culture;
var variantName = GetVariantName(cultureToUse, segment);
var errMsg = Services.TextService.Localize(localizationKey, new[] { variantName });
ModelState.AddVariantValidationError(culture, segment, errMsg);
}
/// <summary>
/// Creates the human readable variant name based on culture and segment
/// </summary>
/// <param name="culture">Culture</param>
/// <param name="segment">Segment</param>
/// <returns></returns>
private string GetVariantName(string culture, string segment)
{
if(culture.IsNullOrWhiteSpace() && segment.IsNullOrWhiteSpace())
{
// TODO: Get name for default variant from somewhere?
return "Default";
}
var cultureName = culture == null ? null : _allLangs.Value[culture].CultureName;
var variantName = string.Join(" — ", new[] { segment, cultureName }.Where(x => !x.IsNullOrWhiteSpace()));
// Format: <segment> [&mdash;] <culture name>
return variantName;
}
/// <summary>
@@ -1839,11 +1875,11 @@ namespace Umbraco.Web.Editors
if (!ModelState.IsValid && display.Variants.Count() > 1)
{
//Add any culture specific errors here
var cultureErrors = ModelState.GetCulturesWithErrors(Services.LocalizationService, cultureForInvariantErrors);
var variantErrors = ModelState.GetVariantsWithErrors(cultureForInvariantErrors);
foreach (var cultureError in cultureErrors)
foreach (var (culture, segment) in variantErrors)
{
AddCultureValidationError(cultureError, "speechBubbles/contentCultureValidationError");
AddVariantValidationError(culture, segment, "speechBubbles/contentCultureValidationError");
}
}

64
src/Umbraco.Web/ModelStateExtensions.cs
View File

@@ -65,11 +65,12 @@ namespace Umbraco.Web
/// </summary>
/// <param name="modelState"></param>
/// <param name="culture"></param>
/// <param name="segment"></param>
/// <param name="errMsg"></param>
internal static void AddCultureValidationError(this System.Web.Http.ModelBinding.ModelStateDictionary modelState,
string culture, string errMsg)
internal static void AddVariantValidationError(this System.Web.Http.ModelBinding.ModelStateDictionary modelState,
string culture, string segment, string errMsg)
{
var key = "_content_variant_" + culture + "_";
var key = "_content_variant_" + (culture.IsNullOrWhiteSpace() ? "invariant" : culture) + "_" + (segment.IsNullOrWhiteSpace() ? "null" : segment) + "_";
if (modelState.ContainsKey(key)) return;
modelState.AddModelError(key, errMsg);
}
@@ -83,23 +84,28 @@ namespace Umbraco.Web
/// <returns>
/// A list of cultures that have property validation errors. The default culture will be returned for any invariant property errors.
/// </returns>
internal static IReadOnlyList<string> GetCulturesWithPropertyErrors(this System.Web.Http.ModelBinding.ModelStateDictionary modelState,
ILocalizationService localizationService, string cultureForInvariantErrors)
internal static IReadOnlyList<(string culture, string segment)> GetVariantsWithPropertyErrors(this System.Web.Http.ModelBinding.ModelStateDictionary modelState,
string cultureForInvariantErrors)
{
//Add any culture specific errors here
var cultureErrors = modelState.Keys
//Add any variant specific errors here
var variantErrors = modelState.Keys
.Where(key => key.StartsWith("_Properties.")) //only choose _Properties errors
.Select(x => x.Split('.')) //split into parts
.Where(x => x.Length >= 3 && x[0] == "_Properties") //only choose _Properties errors
.Select(x => x[2]) //select the culture part
.Where(x => !x.IsNullOrWhiteSpace()) //if it has a value
//if it's marked "invariant" than return the default language, this is because we can only edit invariant properties on the default language
.Where(x => x.Length >= 4 && !x[2].IsNullOrWhiteSpace() && !x[3].IsNullOrWhiteSpace())
.Select(x => (culture: x[2], segment: x[3]))
//if the culture is marked "invariant" than return the default language, this is because we can only edit invariant properties on the default language
//so errors for those must show up under the default lang.
.Select(x => x == "invariant" ? cultureForInvariantErrors : x)
.WhereNotNull()
//if the segment is marked "null" then return an actual null
.Select(x =>
{
var culture = x.culture == "invariant" ? cultureForInvariantErrors : x.culture;
var segment = x.segment == "null" ? null : x.segment;
return (culture, segment);
})
.Distinct()
.ToList();
return cultureErrors;
return variantErrors;
}
/// <summary>
@@ -111,23 +117,33 @@ namespace Umbraco.Web
/// <returns>
/// A list of cultures that have validation errors. The default culture will be returned for any invariant errors.
/// </returns>
internal static IReadOnlyList<string> GetCulturesWithErrors(this System.Web.Http.ModelBinding.ModelStateDictionary modelState,
ILocalizationService localizationService, string cultureForInvariantErrors)
internal static IReadOnlyList<(string culture, string segment)> GetVariantsWithErrors(this System.Web.Http.ModelBinding.ModelStateDictionary modelState, string cultureForInvariantErrors)
{
var propertyCultureErrors = modelState.GetCulturesWithPropertyErrors(localizationService, cultureForInvariantErrors);
var propertyVariantErrors = modelState.GetVariantsWithPropertyErrors(cultureForInvariantErrors);
//now check the other special culture errors that are
var genericCultureErrors = modelState.Keys
//now check the other special variant errors that are
var genericVariantErrors = modelState.Keys
.Where(x => x.StartsWith("_content_variant_") && x.EndsWith("_"))
.Select(x => x.TrimStart("_content_variant_").TrimEnd("_"))
.Where(x => !x.IsNullOrWhiteSpace())
.Select(x => x.TrimStart("_content_variant_").TrimEnd("_"))
.Select(x =>
{
// Format "<culture>_<segment>"
var cs = x.Split(new[] { '_' });
return (culture: cs[0], segment: cs[1]);
})
.Where(x => !x.culture.IsNullOrWhiteSpace())
//if it's marked "invariant" than return the default language, this is because we can only edit invariant properties on the default language
//so errors for those must show up under the default lang.
.Select(x => x == "invariant" ? cultureForInvariantErrors : x)
.WhereNotNull()
//if the segment is marked "null" then return an actual null
.Select(x =>
{
var culture = x.culture == "invariant" ? cultureForInvariantErrors : x.culture;
var segment = x.segment == "null" ? null : x.segment;
return (culture, segment);
})
.Distinct();
return propertyCultureErrors.Union(genericCultureErrors).ToList();
return propertyVariantErrors.Union(genericVariantErrors).Distinct().ToList();
}
/// <summary>

3
src/Umbraco.Web/Mvc/ContentModelBinder.cs
View File

@@ -1,6 +1,4 @@
using System;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.Mvc;
@@ -14,6 +12,7 @@ namespace Umbraco.Web.Mvc
/// <summary>
/// Maps view models, supporting mapping to and from any IPublishedContent or IContentModel.
/// </summary>
/// Migrated to .NET Core
public class ContentModelBinder : DefaultModelBinder, IModelBinderProvider
{
// use Instance

1
src/Umbraco.Web/Mvc/ModelBindingExceptionFilter.cs
View File

@@ -16,6 +16,7 @@ namespace Umbraco.Web.Mvc
/// <remarks>
/// This is only enabled when running PureLive
/// </remarks>
/// Migrated to .NET Core
internal class ModelBindingExceptionFilter : FilterAttribute, IExceptionFilter
{
private static readonly Regex GetPublishedModelsTypesRegex = new Regex("Umbraco.Web.PublishedModels.(\\w+)", RegexOptions.Compiled);