diff --git a/src/Umbraco.Core/Models/ContentRepositoryExtensions.cs b/src/Umbraco.Core/Models/ContentRepositoryExtensions.cs index 2492c95ca4..bf7228ca47 100644 --- a/src/Umbraco.Core/Models/ContentRepositoryExtensions.cs +++ b/src/Umbraco.Core/Models/ContentRepositoryExtensions.cs @@ -166,46 +166,55 @@ namespace Umbraco.Core.Models /// Sets the publishing values for names and properties. /// /// - /// + /// /// A value indicating whether it was possible to publish the names and values for the specified /// culture(s). The method may fail if required names are not set, but it does NOT validate property data - public static bool PublishCulture(this IContent content, CultureType culture) + public static bool PublishCulture(this IContent content, CultureImpact impact) { - if (culture == null) throw new ArgumentNullException(nameof(culture)); + if (impact == null) throw new ArgumentNullException(nameof(impact)); // the variation should be supported by the content type properties // if the content type is invariant, only '*' and 'null' is ok // if the content type varies, everything is ok because some properties may be invariant - if (!content.ContentType.SupportsPropertyVariation(culture.Culture, "*", true)) - throw new NotSupportedException($"Culture \"{culture}\" is not supported by content type \"{content.ContentType.Alias}\" with variation \"{content.ContentType.Variations}\"."); + if (!content.ContentType.SupportsPropertyVariation(impact.Culture, "*", true)) + throw new NotSupportedException($"Culture \"{impact.Culture}\" is not supported by content type \"{content.ContentType.Alias}\" with variation \"{content.ContentType.Variations}\"."); - if (culture.CultureBehavior.HasFlag(CultureType.Behavior.AllCultures)) - foreach (var c in content.AvailableCultures) + // set names + if (impact.ImpactsAllCultures) + { + foreach (var c in content.AvailableCultures) // does NOT contain the invariant culture { var name = content.GetCultureName(c); if (string.IsNullOrWhiteSpace(name)) return false; content.SetPublishInfo(c, name, DateTime.Now); } - else if (culture.CultureBehavior.HasFlag(CultureType.Behavior.InvariantCulture)) + } + else if (impact.ImpactsOnlyInvariantCulture) { if (string.IsNullOrWhiteSpace(content.Name)) return false; // PublishName set by repository - nothing to do here } - else if (culture.CultureBehavior.HasFlag(CultureType.Behavior.ExplicitCulture)) + else if (impact.ImpactsExplicitCulture) { - var name = content.GetCultureName(culture.Culture); + var name = content.GetCultureName(impact.Culture); if (string.IsNullOrWhiteSpace(name)) return false; - content.SetPublishInfo(culture.Culture, name, DateTime.Now); + content.SetPublishInfo(impact.Culture, name, DateTime.Now); } - // property.PublishValues only publishes what is valid, variation-wise + // set values + // property.PublishValues only publishes what is valid, variation-wise, + // but accepts any culture arg: null, all, specific foreach (var property in content.Properties) { - property.PublishValues(culture.Culture); - if (culture.CultureBehavior.HasFlag(CultureType.Behavior.InvariantProperties)) + // for the specified culture (null or all or specific) + property.PublishValues(impact.Culture); + + // maybe the specified culture did not impact the invariant culture, so PublishValues + // above would skip it, yet it *also* impacts invariant properties + if (impact.ImpactsAlsoInvariantProperties) property.PublishValues(null); } diff --git a/src/Umbraco.Core/Models/CultureImpact.cs b/src/Umbraco.Core/Models/CultureImpact.cs new file mode 100644 index 0000000000..4e6b6a1a36 --- /dev/null +++ b/src/Umbraco.Core/Models/CultureImpact.cs @@ -0,0 +1,232 @@ +using System; + +namespace Umbraco.Core.Models +{ + /// + /// Represents the impact of a culture set. + /// + /// + /// A set of cultures can be either all cultures (including the invariant culture), or + /// the invariant culture, or a specific culture. + /// + internal class CultureImpact + { + /// + /// Initializes a new instance of the class. + /// + /// The culture code. + /// A value indicating whether the culture is the default culture. + private CultureImpact(string culture, bool isDefault = false) + { + if (culture != null && culture.IsNullOrWhiteSpace()) + throw new ArgumentException("Culture \"\" is not valid here."); + + Culture = culture; + + if ((culture == null || culture == "*") && isDefault) + throw new ArgumentException("The invariant or 'all' culture can not be the default culture."); + + ImpactsOnlyDefaultCulture = isDefault; + } + + /// + /// Gets the impact of 'all' cultures (including the invariant culture). + /// + public static CultureImpact All { get; } = new CultureImpact("*"); + + /// + /// Gets the impact of the invariant culture. + /// + public static CultureImpact Invariant { get; } = new CultureImpact(null); + + /// + /// Creates an impact instance representing the impact of a specific culture. + /// + /// The culture code. + /// A value indicating whether the culture is the default culture. + public static CultureImpact Explicit(string culture, bool isDefault) + { + if (culture == null) + throw new ArgumentException("Culture is not explicit."); + if (culture.IsNullOrWhiteSpace()) + throw new ArgumentException("Culture \"\" is not explicit."); + if (culture == "*") + throw new ArgumentException("Culture \"*\" is not explicit."); + + return new CultureImpact(culture, isDefault); + } + + /// + /// Creates an impact instance representing the impact of a culture set, + /// in the context of a content item variation. + /// + /// The culture code. + /// A value indicating whether the culture is the default culture. + /// The content item. + /// + /// Validates that the culture is compatible with the variation. + /// + public static CultureImpact Create(string culture, bool isDefault, IContent content) + { + // throws if not successful + TryCreate(culture, isDefault, content.ContentType.Variations, true, out var impact); + return impact; + } + + /// + /// Tries to create an impact instance representing the impact of a culture set, + /// in the context of a content item variation. + /// + /// The culture code. + /// A value indicating whether the culture is the default culture. + /// A content variation. + /// A value indicating whether to throw if the impact cannot be created. + /// The impact if it could be created, otherwise null. + /// A value indicating whether the impact could be created. + /// + /// Validates that the culture is compatible with the variation. + /// + internal static bool TryCreate(string culture, bool isDefault, ContentVariation variation, bool throwOnFail, out CultureImpact impact) + { + impact = null; + + // if culture is invariant... + if (culture == null) + { + // ... then variation must not vary by culture ... + if (variation.VariesByCulture()) + { + if (throwOnFail) + throw new InvalidOperationException("The invariant culture is not compatible with a varying variation."); + return false; + } + + // ... and it cannot be default + if (isDefault) + { + if (throwOnFail) + throw new InvalidOperationException("The invariant culture can not be the default culture."); + return false; + } + + impact = Invariant; + return true; + } + + // if culture is 'all'... + if (culture == "*") + { + // ... it cannot be default + if (isDefault) + { + if (throwOnFail) + throw new InvalidOperationException("The 'all' culture can not be the default culture."); + return false; + } + + // if variation does not vary by culture, then impact is invariant + impact = variation.VariesByCulture() ? All : Invariant; + return true; + } + + // neither null nor "*" - cannot be the empty string + if (culture.IsNullOrWhiteSpace()) + { + if (throwOnFail) + throw new ArgumentException("Cannot be the empty string.", nameof(culture)); + return false; + } + + // if culture is specific, then variation must vary + if (!variation.VariesByCulture()) + { + if (throwOnFail) + throw new InvalidOperationException($"The variant culture {culture} is not compatible with an invariant variation."); + return false; + } + + // return specific impact + impact = new CultureImpact(culture, isDefault); + return true; + } + + /// + /// Gets the culture code. + /// + /// + /// Can be null (invariant) or * (all cultures) or a specific culture code. + /// + public string Culture { get; } + + /// + /// Gets a value indicating whether this impact impacts all cultures, including, + /// indirectly, the invariant culture. + /// + public bool ImpactsAllCultures => Culture == "*"; + + /// + /// Gets a value indicating whether this impact impacts only the invariant culture, + /// directly, not because all cultures are impacted. + /// + public bool ImpactsOnlyInvariantCulture => Culture == null; + + /// + /// Gets a value indicating whether this impact impacts an implicit culture. + /// + /// And then it does not impact the invariant culture. The impacted + /// explicit culture could be the default culture. + public bool ImpactsExplicitCulture => Culture != null && Culture != "*"; + + /// + /// Gets a value indicating whether this impact impacts the default culture, directly, + /// not because all cultures are impacted. + /// + public bool ImpactsOnlyDefaultCulture {get; } + + /// + /// Gets a value indicating whether this impact impacts the invariant properties, either + /// directly, or because all cultures are impacted, or because the default culture is impacted. + /// + public bool ImpactsInvariantProperties => Culture == null || Culture == "*" || ImpactsOnlyDefaultCulture; + + /// + /// Gets a value indicating whether this also impact impacts the invariant properties, + /// even though it does not impact the invariant culture, neither directly (ImpactsInvariantCulture) + /// nor indirectly (ImpactsAllCultures). + /// + public bool ImpactsAlsoInvariantProperties => !ImpactsOnlyInvariantCulture && + !ImpactsAllCultures && + ImpactsOnlyDefaultCulture; + + public Behavior CultureBehavior + { + get + { + //null can only be invariant + if (Culture == null) return Behavior.InvariantCulture | Behavior.InvariantProperties; + + // * is All which means its also invariant properties since this will include the default language + if (Culture == "*") return (Behavior.AllCultures | Behavior.InvariantProperties); + + //else it's explicit + var result = Behavior.ExplicitCulture; + + //if the explicit culture is the default, then the behavior is also InvariantProperties + if (ImpactsOnlyDefaultCulture) + result |= Behavior.InvariantProperties; + + return result; + } + } + + + [Flags] + public enum Behavior : byte + { + AllCultures = 1, + InvariantCulture = 2, + ExplicitCulture = 4, + InvariantProperties = 8 + } + } +} diff --git a/src/Umbraco.Core/Models/CultureType.cs b/src/Umbraco.Core/Models/CultureType.cs deleted file mode 100644 index e273cbdc3a..0000000000 --- a/src/Umbraco.Core/Models/CultureType.cs +++ /dev/null @@ -1,105 +0,0 @@ -using System; - -namespace Umbraco.Core.Models -{ - /// - /// A represents either All cultures, a Single culture or the Invariant culture - /// - internal class CultureType - { - /// - /// Represents All cultures - /// - public static CultureType All { get; } = new CultureType("*"); - - /// - /// Represents the Invariant culture - /// - public static CultureType Invariant { get; } = new CultureType(null); - - /// - /// Represents a Single culture - /// - /// - /// - /// - public static CultureType Explicit(string culture, bool isDefault) - { - return new CultureType(culture, isDefault); - } - - /// - /// Creates a based on a item - /// - /// - /// - /// - /// - public static CultureType Create(IContent content, string culture, bool isDefault) - { - if (!TryCreate(content.ContentType.Variations, culture, isDefault, out var cultureType)) - throw new InvalidOperationException($"The null value for culture is reserved for invariant content but the content type {content.ContentType.Alias} is variant"); - - return cultureType; - } - - internal static bool TryCreate(ContentVariation variation, string culture, bool isDefault, out CultureType cultureType) - { - cultureType = null; - if (culture == null || culture == "*") - { - if (culture == null && variation.VariesByCulture()) - return false; - - //we support * for invariant since it means ALL but we need to explicitly translate it so it's behavior is Invariant - if (culture == "*" && !variation.VariesByCulture()) - { - cultureType = new CultureType(null, isDefault); - return true; - } - } - - cultureType = new CultureType(culture, isDefault); - return true; - } - - private CultureType(string culture, bool isDefault = false) - { - Culture = culture; - IsDefaultCulture = isDefault; - } - - public string Culture { get; } - public Behavior CultureBehavior - { - get - { - //null can only be invariant - if (Culture == null) return Behavior.InvariantCulture | Behavior.InvariantProperties; - - // * is All which means its also invariant properties since this will include the default language - if (Culture == "*") return (Behavior.AllCultures | Behavior.InvariantProperties); - - //else it's explicit - var result = Behavior.ExplicitCulture; - - //if the explicit culture is the default, then the behavior is also InvariantProperties - if (IsDefaultCulture) - result |= Behavior.InvariantProperties; - - return result; - } - } - - public bool IsDefaultCulture { get; } - - [Flags] - public enum Behavior : byte - { - AllCultures = 1, - InvariantCulture = 2, - ExplicitCulture = 4, - InvariantProperties = 8 - } - } -} diff --git a/src/Umbraco.Core/Services/Implement/ContentService.cs b/src/Umbraco.Core/Services/Implement/ContentService.cs index eef26be7da..cb0e061427 100644 --- a/src/Umbraco.Core/Services/Implement/ContentService.cs +++ b/src/Umbraco.Core/Services/Implement/ContentService.cs @@ -881,12 +881,12 @@ namespace Umbraco.Core.Services.Implement // if culture is specific, first publish the invariant values, then publish the culture itself. // if culture is '*', then publish them all (including variants) - //this will create the correct culture type even if culture is * or null - var cultureType = CultureType.Create(content, culture, _languageRepository.IsDefault(culture)); + //this will create the correct culture impact even if culture is * or null + var impact = CultureImpact.Create(culture, _languageRepository.IsDefault(culture), content); // publish the culture(s) // we don't care about the response here, this response will be rechecked below but we need to set the culture info values now. - content.PublishCulture(cultureType); + content.PublishCulture(impact); var result = CommitDocumentChangesInternal(scope, content, saveEventArgs, userId, raiseEvents); scope.Complete(); @@ -922,12 +922,12 @@ namespace Umbraco.Core.Services.Implement if (cultures.Any(x => x == null || x == "*")) throw new InvalidOperationException("Only valid cultures are allowed to be used in this method, wildcards or nulls are not allowed"); - var cultureTypes = cultures.Select(x => CultureType.Explicit(x, _languageRepository.IsDefault(x))); + var impacts = cultures.Select(x => CultureImpact.Explicit(x, _languageRepository.IsDefault(x))); // publish the culture(s) // we don't care about the response here, this response will be rechecked below but we need to set the culture info values now. - foreach (var cultureType in cultureTypes) - content.PublishCulture(cultureType); + foreach (var impact in impacts) + content.PublishCulture(impact); var result = CommitDocumentChangesInternal(scope, content, saveEventArgs, userId, raiseEvents); scope.Complete(); @@ -1308,8 +1308,8 @@ namespace Umbraco.Core.Services.Implement //publish the culture values and validate the property values, if validation fails, log the invalid properties so the develeper has an idea of what has failed Property[] invalidProperties = null; - var cultureType = CultureType.Explicit(culture, _languageRepository.IsDefault(culture)); - var tryPublish = d.PublishCulture(cultureType) && _propertyValidationService.Value.IsPropertyDataValid(d, out invalidProperties, cultureType); + var impact = CultureImpact.Explicit(culture, _languageRepository.IsDefault(culture)); + var tryPublish = d.PublishCulture(impact) && _propertyValidationService.Value.IsPropertyDataValid(d, out invalidProperties, impact); if (invalidProperties != null && invalidProperties.Length > 0) Logger.Warn("Scheduled publishing will fail for document {DocumentId} and culture {Culture} because of invalid properties {InvalidProperties}", d.Id, culture, string.Join(",", invalidProperties.Select(x => x.Alias))); @@ -1409,13 +1409,15 @@ namespace Umbraco.Core.Services.Implement { return culturesToPublish.All(culture => { - var cultureType = CultureType.Explicit(culture, _languageRepository.IsDefault(culture)); - return content.PublishCulture(cultureType) && _propertyValidationService.Value.IsPropertyDataValid(content, out _, cultureType); + // fixme - not ... ah?! + //var cultureType = CultureImpact.Explicit(culture, _languageRepository.IsDefault(culture)); + var impact = CultureImpact.Create(culture, _languageRepository.IsDefault(culture), content); + return content.PublishCulture(impact) && _propertyValidationService.Value.IsPropertyDataValid(content, out _, impact); }); } - return content.PublishCulture(CultureType.Invariant) - && _propertyValidationService.Value.IsPropertyDataValid(content, out _, CultureType.Invariant); + return content.PublishCulture(CultureImpact.Invariant) + && _propertyValidationService.Value.IsPropertyDataValid(content, out _, CultureImpact.Invariant); } // utility 'ShouldPublish' func used by SaveAndPublishBranch @@ -2487,17 +2489,17 @@ namespace Umbraco.Core.Services.Implement var variesByCulture = content.ContentType.VariesByCulture(); - var cultureTypesToPublish = culturesPublishing == null - ? new[] {CultureType.Invariant} //if it's null it's invariant - : culturesPublishing.Select(x => CultureType.Explicit(x, _languageRepository.IsDefault(x))).ToArray(); + var impactsToPublish = culturesPublishing == null + ? new[] {CultureImpact.Invariant} //if it's null it's invariant + : culturesPublishing.Select(x => CultureImpact.Explicit(x, _languageRepository.IsDefault(x))).ToArray(); // publish the culture(s) - if (!cultureTypesToPublish.All(content.PublishCulture)) + if (!impactsToPublish.All(content.PublishCulture)) return new PublishResult(PublishResultType.FailedPublishContentInvalid, evtMsgs, content); //validate the property values Property[] invalidProperties = null; - if (!cultureTypesToPublish.All(x => _propertyValidationService.Value.IsPropertyDataValid(content, out invalidProperties, x))) + if (!impactsToPublish.All(x => _propertyValidationService.Value.IsPropertyDataValid(content, out invalidProperties, x))) return new PublishResult(PublishResultType.FailedPublishContentInvalid, evtMsgs, content) { InvalidProperties = invalidProperties diff --git a/src/Umbraco.Core/Services/PropertyValidationService.cs b/src/Umbraco.Core/Services/PropertyValidationService.cs index 800f4126f0..b846095bd1 100644 --- a/src/Umbraco.Core/Services/PropertyValidationService.cs +++ b/src/Umbraco.Core/Services/PropertyValidationService.cs @@ -31,35 +31,32 @@ namespace Umbraco.Core.Services /// /// Validates the content item's properties pass validation rules /// - public bool IsPropertyDataValid(IContent content, out Property[] invalidProperties, CultureType culture) + public bool IsPropertyDataValid(IContent content, out Property[] invalidProperties, CultureImpact impact) { // select invalid properties invalidProperties = content.Properties.Where(x => { - // if culture is null, we validate invariant properties only - // if culture is '*' we validate both variant and invariant properties, automatically - // if culture is specific eg 'en-US' we both too, but explicitly - var propertyTypeVaries = x.PropertyType.VariesByCulture(); - if (culture.CultureBehavior.HasFlag(CultureType.Behavior.InvariantCulture)) - return !(propertyTypeVaries || IsPropertyValid(x, null)); // validate invariant property, invariant culture + // impacts invariant = validate invariant property, invariant culture + if (impact.ImpactsOnlyInvariantCulture) + return !(propertyTypeVaries || IsPropertyValid(x, null)); - if (culture.CultureBehavior.HasFlag(CultureType.Behavior.AllCultures)) - return !IsPropertyValid(x, culture.Culture); // validate property, all cultures - - //we're dealing with Behavior.Explicit now... + // impacts all = validate property, all cultures (incl. invariant) + if (impact.ImpactsAllCultures) + return !IsPropertyValid(x); + // impacts explicit culture = validate variant property, explicit culture if (propertyTypeVaries) - return !IsPropertyValid(x, culture.Culture); // validate variant property, explicit culture + return !IsPropertyValid(x, impact.Culture); - //Validate invariant properties on the default language (will have the Behavior.InvariantProperties) - // or if there is no published version of the content, in which case it doesn't matter which culture is publishing + // and, for explicit culture, we may also have to validate invariant property, invariant culture + // if either + // - it is impacted (default culture), or + // - there is no published version of the content - maybe non-default culture, but no published version - var shouldValidate = culture.CultureBehavior.HasFlag(CultureType.Behavior.InvariantProperties) //default language - || !content.Published; //non-default language but no published version - - return shouldValidate && !IsPropertyValid(x, null); // validate invariant property, explicit culture + var alsoInvariant = impact.ImpactsAlsoInvariantProperties || !content.Published; + return alsoInvariant && !IsPropertyValid(x, null); }).ToArray(); diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj index b8ab60eca6..656d15bf51 100755 --- a/src/Umbraco.Core/Umbraco.Core.csproj +++ b/src/Umbraco.Core/Umbraco.Core.csproj @@ -209,7 +209,7 @@ - + diff --git a/src/Umbraco.Tests/Models/ContentTests.cs b/src/Umbraco.Tests/Models/ContentTests.cs index 643ccfb788..3116087669 100644 --- a/src/Umbraco.Tests/Models/ContentTests.cs +++ b/src/Umbraco.Tests/Models/ContentTests.cs @@ -104,7 +104,7 @@ namespace Umbraco.Tests.Models Thread.Sleep(500); //The "Date" wont be dirty if the test runs too fast since it will be the same date content.SetCultureName("name-fr", langFr); - content.PublishCulture(CultureType.Explicit(langFr, false)); //we've set the name, now we're publishing it + content.PublishCulture(CultureImpact.Explicit(langFr, false)); //we've set the name, now we're publishing it Assert.IsTrue(content.IsPropertyDirty("PublishCultureInfos")); //now it will be changed since the collection has changed var frCultureName = content.PublishCultureInfos[langFr]; Assert.IsTrue(frCultureName.IsPropertyDirty("Date")); @@ -116,7 +116,7 @@ namespace Umbraco.Tests.Models Thread.Sleep(500); //The "Date" wont be dirty if the test runs too fast since it will be the same date content.SetCultureName("name-fr", langFr); - content.PublishCulture(CultureType.Explicit(langFr, false)); //we've set the name, now we're publishing it + content.PublishCulture(CultureImpact.Explicit(langFr, false)); //we've set the name, now we're publishing it Assert.IsTrue(frCultureName.IsPropertyDirty("Date")); Assert.IsTrue(content.IsPropertyDirty("PublishCultureInfos")); //it's true now since we've updated a name } @@ -303,7 +303,7 @@ namespace Umbraco.Tests.Models content.SetCultureName("Hello", "en-US"); content.SetCultureName("World", "es-ES"); - content.PublishCulture(CultureType.All); + content.PublishCulture(CultureImpact.All); // should not try to clone something that's not Published or Unpublished // (and in fact it will not work) @@ -414,7 +414,7 @@ namespace Umbraco.Tests.Models content.SetCultureName("Hello", "en-US"); content.SetCultureName("World", "es-ES"); - content.PublishCulture(CultureType.All); + content.PublishCulture(CultureImpact.All); var i = 200; foreach (var property in content.Properties) diff --git a/src/Umbraco.Tests/Models/CultureImpactTests.cs b/src/Umbraco.Tests/Models/CultureImpactTests.cs new file mode 100644 index 0000000000..9badbd6c34 --- /dev/null +++ b/src/Umbraco.Tests/Models/CultureImpactTests.cs @@ -0,0 +1,139 @@ +using NUnit.Framework; +using Umbraco.Core.Models; + +namespace Umbraco.Tests.Models +{ + [TestFixture] + public class CultureImpactTests + { + [Test] + public void All_Cultures() + { + var impact = CultureImpact.All; + + Assert.AreEqual(impact.Culture, "*"); + + Assert.IsTrue(impact.ImpactsInvariantProperties); + Assert.IsFalse(impact.ImpactsAlsoInvariantProperties); + Assert.IsFalse(impact.ImpactsOnlyInvariantCulture); + Assert.IsFalse(impact.ImpactsExplicitCulture); + Assert.IsTrue(impact.ImpactsAllCultures); + Assert.IsFalse(impact.ImpactsOnlyDefaultCulture); + } + + [Test] + public void Invariant_Culture() + { + var impact = CultureImpact.Invariant; + + Assert.AreEqual(impact.Culture, null); + + Assert.IsTrue(impact.ImpactsInvariantProperties); + Assert.IsFalse(impact.ImpactsAlsoInvariantProperties); + Assert.IsTrue(impact.ImpactsOnlyInvariantCulture); + Assert.IsFalse(impact.ImpactsExplicitCulture); + Assert.IsFalse(impact.ImpactsAllCultures); + Assert.IsFalse(impact.ImpactsOnlyDefaultCulture); + } + + [Test] + public void Explicit_Default_Culture() + { + var impact = CultureImpact.Explicit("en-US", true); + + Assert.AreEqual(impact.Culture, "en-US"); + + Assert.IsTrue(impact.ImpactsInvariantProperties); + Assert.IsTrue(impact.ImpactsAlsoInvariantProperties); + Assert.IsFalse(impact.ImpactsOnlyInvariantCulture); + Assert.IsTrue(impact.ImpactsExplicitCulture); + Assert.IsFalse(impact.ImpactsAllCultures); + Assert.IsTrue(impact.ImpactsOnlyDefaultCulture); + } + + [Test] + public void Explicit_NonDefault_Culture() + { + var impact = CultureImpact.Explicit("en-US", false); + + Assert.AreEqual(impact.Culture, "en-US"); + + Assert.IsFalse(impact.ImpactsInvariantProperties); + Assert.IsFalse(impact.ImpactsAlsoInvariantProperties); + Assert.IsFalse(impact.ImpactsOnlyInvariantCulture); + Assert.IsTrue(impact.ImpactsExplicitCulture); + Assert.IsFalse(impact.ImpactsAllCultures); + Assert.IsFalse(impact.ImpactsOnlyDefaultCulture); + } + + [Test] + public void TryCreate_Explicit_Default_Culture() + { + var success = CultureImpact.TryCreate("en-US", true, ContentVariation.Culture, false, out var impact); + Assert.IsTrue(success); + + Assert.AreEqual(impact.Culture, "en-US"); + + Assert.IsTrue(impact.ImpactsInvariantProperties); + Assert.IsTrue(impact.ImpactsAlsoInvariantProperties); + Assert.IsFalse(impact.ImpactsOnlyInvariantCulture); + Assert.IsTrue(impact.ImpactsExplicitCulture); + Assert.IsFalse(impact.ImpactsAllCultures); + Assert.IsTrue(impact.ImpactsOnlyDefaultCulture); + } + + [Test] + public void TryCreate_Explicit_NonDefault_Culture() + { + var success = CultureImpact.TryCreate("en-US", false, ContentVariation.Culture, false, out var impact); + Assert.IsTrue(success); + + Assert.AreEqual(impact.Culture, "en-US"); + + Assert.IsFalse(impact.ImpactsInvariantProperties); + Assert.IsFalse(impact.ImpactsAlsoInvariantProperties); + Assert.IsFalse(impact.ImpactsOnlyInvariantCulture); + Assert.IsTrue(impact.ImpactsExplicitCulture); + Assert.IsFalse(impact.ImpactsAllCultures); + Assert.IsFalse(impact.ImpactsOnlyDefaultCulture); + } + + [Test] + public void TryCreate_AllCultures_For_Invariant() + { + var success = CultureImpact.TryCreate("*", false, ContentVariation.Nothing, false, out var impact); + Assert.IsTrue(success); + + Assert.AreEqual(impact.Culture, null); + + Assert.AreSame(CultureImpact.Invariant, impact); + } + + [Test] + public void TryCreate_AllCultures_For_Variant() + { + var success = CultureImpact.TryCreate("*", false, ContentVariation.Culture, false, out var impact); + Assert.IsTrue(success); + + Assert.AreEqual(impact.Culture, "*"); + + Assert.AreSame(CultureImpact.All, impact); + } + + [Test] + public void TryCreate_Invariant_For_Variant() + { + var success = CultureImpact.TryCreate(null, false, ContentVariation.Culture, false, out var impact); + Assert.IsFalse(success); + } + + [Test] + public void TryCreate_Invariant_For_Invariant() + { + var success = CultureImpact.TryCreate(null, false, ContentVariation.Nothing, false, out var impact); + Assert.IsTrue(success); + + Assert.AreSame(CultureImpact.Invariant, impact); + } + } +} diff --git a/src/Umbraco.Tests/Models/CultureTypeTests.cs b/src/Umbraco.Tests/Models/CultureTypeTests.cs deleted file mode 100644 index 9b6c0149da..0000000000 --- a/src/Umbraco.Tests/Models/CultureTypeTests.cs +++ /dev/null @@ -1,138 +0,0 @@ -using NUnit.Framework; -using Umbraco.Core.Models; - -namespace Umbraco.Tests.Models -{ - [TestFixture] - public class CultureTypeTests - { - [Test] - public void All() - { - var ct = CultureType.All; - - Assert.AreEqual(ct.Culture, "*"); - Assert.IsTrue(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantProperties)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantCulture)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.ExplicitCulture)); - Assert.IsTrue(ct.CultureBehavior.HasFlag(CultureType.Behavior.AllCultures)); - Assert.IsFalse(ct.IsDefaultCulture); - } - - [Test] - public void Invariant() - { - var ct = CultureType.Invariant; - - Assert.AreEqual(ct.Culture, null); - Assert.IsTrue(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantProperties)); - Assert.IsTrue(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantCulture)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.ExplicitCulture)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.AllCultures)); - Assert.IsFalse(ct.IsDefaultCulture); - } - - [Test] - public void Single_Default_Culture() - { - var ct = CultureType.Explicit("en-US", true); - - Assert.AreEqual(ct.Culture, "en-US"); - Assert.IsTrue(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantProperties)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantCulture)); - Assert.IsTrue(ct.CultureBehavior.HasFlag(CultureType.Behavior.ExplicitCulture)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.AllCultures)); - Assert.IsTrue(ct.IsDefaultCulture); - } - - [Test] - public void Single_Non_Default_Culture() - { - var ct = CultureType.Explicit("en-US", false); - - Assert.AreEqual(ct.Culture, "en-US"); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantProperties)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantCulture)); - Assert.IsTrue(ct.CultureBehavior.HasFlag(CultureType.Behavior.ExplicitCulture)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.AllCultures)); - Assert.IsFalse(ct.IsDefaultCulture); - } - - [Test] - public void Try_Create_Explicit_Default_Culture() - { - var success = CultureType.TryCreate(ContentVariation.Culture, "en-US", true, out var ct); - Assert.IsTrue(success); - - Assert.AreEqual(ct.Culture, "en-US"); - Assert.IsTrue(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantProperties)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantCulture)); - Assert.IsTrue(ct.CultureBehavior.HasFlag(CultureType.Behavior.ExplicitCulture)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.AllCultures)); - Assert.IsTrue(ct.IsDefaultCulture); - } - - [Test] - public void Try_Create_Explicit_Non_Default_Culture() - { - var success = CultureType.TryCreate(ContentVariation.Culture, "en-US", false, out var ct); - Assert.IsTrue(success); - - Assert.AreEqual(ct.Culture, "en-US"); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantProperties)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantCulture)); - Assert.IsTrue(ct.CultureBehavior.HasFlag(CultureType.Behavior.ExplicitCulture)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.AllCultures)); - Assert.IsFalse(ct.IsDefaultCulture); - } - - [Test] - public void Try_Create_Wildcard_Invariant() - { - var success = CultureType.TryCreate(ContentVariation.Nothing, "*", false, out var ct); - Assert.IsTrue(success); - - Assert.AreEqual(ct.Culture, null); - Assert.IsTrue(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantProperties)); - Assert.IsTrue(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantCulture)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.ExplicitCulture)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.AllCultures)); - Assert.IsFalse(ct.IsDefaultCulture); - } - - [Test] - public void Try_Create_Wildcard_Variant() - { - var success = CultureType.TryCreate(ContentVariation.Culture, "*", false, out var ct); - Assert.IsTrue(success); - - Assert.AreEqual(ct.Culture, "*"); - Assert.IsTrue(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantProperties)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantCulture)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.ExplicitCulture)); - Assert.IsTrue(ct.CultureBehavior.HasFlag(CultureType.Behavior.AllCultures)); - Assert.IsFalse(ct.IsDefaultCulture); - } - - [Test] - public void Try_Create_Null_Variant() - { - var success = CultureType.TryCreate(ContentVariation.Culture, null, false, out var ct); - Assert.IsFalse(success); - } - - [Test] - public void Try_Create_Null_Invariant() - { - var success = CultureType.TryCreate(ContentVariation.Nothing, null, false, out var ct); - Assert.IsTrue(success); - - Assert.AreEqual(ct.Culture, null); - Assert.IsTrue(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantProperties)); - Assert.IsTrue(ct.CultureBehavior.HasFlag(CultureType.Behavior.InvariantCulture)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.ExplicitCulture)); - Assert.IsFalse(ct.CultureBehavior.HasFlag(CultureType.Behavior.AllCultures)); - Assert.IsFalse(ct.IsDefaultCulture); - } - } -} diff --git a/src/Umbraco.Tests/Models/VariationTests.cs b/src/Umbraco.Tests/Models/VariationTests.cs index 8d86db5236..8d64a6d28f 100644 --- a/src/Umbraco.Tests/Models/VariationTests.cs +++ b/src/Umbraco.Tests/Models/VariationTests.cs @@ -275,7 +275,7 @@ namespace Umbraco.Tests.Models // can publish value // and get edited and published values - Assert.IsTrue(content.PublishCulture(CultureType.All)); + Assert.IsTrue(content.PublishCulture(CultureImpact.All)); Assert.AreEqual("a", content.GetValue("prop")); Assert.AreEqual("a", content.GetValue("prop", published: true)); @@ -305,9 +305,9 @@ namespace Umbraco.Tests.Models // can publish value // and get edited and published values - Assert.IsFalse(content.PublishCulture(CultureType.Explicit(langFr, false))); // no name + Assert.IsFalse(content.PublishCulture(CultureImpact.Explicit(langFr, false))); // no name content.SetCultureName("name-fr", langFr); - Assert.IsTrue(content.PublishCulture(CultureType.Explicit(langFr, false))); + Assert.IsTrue(content.PublishCulture(CultureImpact.Explicit(langFr, false))); Assert.IsNull(content.GetValue("prop")); Assert.IsNull(content.GetValue("prop", published: true)); Assert.AreEqual("c", content.GetValue("prop", langFr)); @@ -321,7 +321,7 @@ namespace Umbraco.Tests.Models Assert.IsNull(content.GetValue("prop", langFr, published: true)); // can publish all - Assert.IsTrue(content.PublishCulture(CultureType.All)); + Assert.IsTrue(content.PublishCulture(CultureImpact.All)); Assert.IsNull(content.GetValue("prop")); Assert.IsNull(content.GetValue("prop", published: true)); Assert.AreEqual("c", content.GetValue("prop", langFr)); @@ -331,14 +331,14 @@ namespace Umbraco.Tests.Models content.UnpublishCulture(langFr); Assert.AreEqual("c", content.GetValue("prop", langFr)); Assert.IsNull(content.GetValue("prop", langFr, published: true)); - Assert.IsTrue(content.PublishCulture(CultureType.Explicit(langFr, false))); + Assert.IsTrue(content.PublishCulture(CultureImpact.Explicit(langFr, false))); Assert.AreEqual("c", content.GetValue("prop", langFr)); Assert.AreEqual("c", content.GetValue("prop", langFr, published: true)); content.UnpublishCulture(); // clears invariant props if any Assert.IsNull(content.GetValue("prop")); Assert.IsNull(content.GetValue("prop", published: true)); - Assert.IsTrue(content.PublishCulture(CultureType.All)); // publishes invariant props if any + Assert.IsTrue(content.PublishCulture(CultureImpact.All)); // publishes invariant props if any Assert.IsNull(content.GetValue("prop")); Assert.IsNull(content.GetValue("prop", published: true)); @@ -385,19 +385,19 @@ namespace Umbraco.Tests.Models content.SetCultureName("hello", langFr); //for this test we'll make the french culture the default one - this is needed for publishing invariant property values - var langFrCultureType = CultureType.Explicit(langFr, true); + var langFrImpact = CultureImpact.Explicit(langFr, true); - Assert.IsTrue(content.PublishCulture(langFrCultureType)); // succeeds because names are ok (not validating properties here) - Assert.IsFalse(propertyValidationService.IsPropertyDataValid(content, out _, langFrCultureType));// fails because prop1 is mandatory + Assert.IsTrue(content.PublishCulture(langFrImpact)); // succeeds because names are ok (not validating properties here) + Assert.IsFalse(propertyValidationService.IsPropertyDataValid(content, out _, langFrImpact));// fails because prop1 is mandatory content.SetValue("prop1", "a", langFr); - Assert.IsTrue(content.PublishCulture(langFrCultureType)); // succeeds because names are ok (not validating properties here) + Assert.IsTrue(content.PublishCulture(langFrImpact)); // succeeds because names are ok (not validating properties here) // fails because prop2 is mandatory and invariant and the item isn't published. // Invariant is validated against the default language except when there isn't a published version, in that case it's always validated. - Assert.IsFalse(propertyValidationService.IsPropertyDataValid(content, out _, langFrCultureType)); + Assert.IsFalse(propertyValidationService.IsPropertyDataValid(content, out _, langFrImpact)); content.SetValue("prop2", "x"); - Assert.IsTrue(content.PublishCulture(langFrCultureType)); // still ok... - Assert.IsTrue(propertyValidationService.IsPropertyDataValid(content, out _, langFrCultureType));// now it's ok + Assert.IsTrue(content.PublishCulture(langFrImpact)); // still ok... + Assert.IsTrue(propertyValidationService.IsPropertyDataValid(content, out _, langFrImpact));// now it's ok Assert.AreEqual("a", content.GetValue("prop1", langFr, published: true)); Assert.AreEqual("x", content.GetValue("prop2", published: true)); @@ -428,12 +428,12 @@ namespace Umbraco.Tests.Models content.SetValue("prop", "a-es", langEs); // cannot publish without a name - Assert.IsFalse(content.PublishCulture(CultureType.Explicit(langFr, false))); + Assert.IsFalse(content.PublishCulture(CultureImpact.Explicit(langFr, false))); // works with a name // and then FR is available, and published content.SetCultureName("name-fr", langFr); - Assert.IsTrue(content.PublishCulture(CultureType.Explicit(langFr, false))); + Assert.IsTrue(content.PublishCulture(CultureImpact.Explicit(langFr, false))); // now UK is available too content.SetCultureName("name-uk", langUk); diff --git a/src/Umbraco.Tests/Persistence/NPocoTests/PetaPocoCachesTest.cs b/src/Umbraco.Tests/Persistence/NPocoTests/PetaPocoCachesTest.cs index 6a7f929cb3..5372a12ac2 100644 --- a/src/Umbraco.Tests/Persistence/NPocoTests/PetaPocoCachesTest.cs +++ b/src/Umbraco.Tests/Persistence/NPocoTests/PetaPocoCachesTest.cs @@ -181,13 +181,13 @@ namespace Umbraco.Tests.Persistence.NPocoTests contentTypeService.Save(contentType); var content1 = MockedContent.CreateSimpleContent(contentType, "Tagged content 1", -1); content1.AssignTags("tags", new[] { "hello", "world", "some", "tags" }); - content1.PublishCulture(CultureType.Invariant); + content1.PublishCulture(CultureImpact.Invariant); contentService.SaveAndPublish(content1); id2 = content1.Id; var content2 = MockedContent.CreateSimpleContent(contentType, "Tagged content 2", -1); content2.AssignTags("tags", new[] { "hello", "world", "some", "tags" }); - content2.PublishCulture(CultureType.Invariant); + content2.PublishCulture(CultureImpact.Invariant); contentService.SaveAndPublish(content2); id3 = content2.Id; diff --git a/src/Umbraco.Tests/Persistence/Repositories/DocumentRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/DocumentRepositoryTest.cs index 32839da996..c7a83717a8 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/DocumentRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/DocumentRepositoryTest.cs @@ -141,7 +141,7 @@ namespace Umbraco.Tests.Persistence.Repositories // publish = new edit version content1.SetValue("title", "title"); - content1.PublishCulture(CultureType.Invariant); + content1.PublishCulture(CultureImpact.Invariant); content1.PublishedState = PublishedState.Publishing; repository.Save(content1); @@ -203,7 +203,7 @@ namespace Umbraco.Tests.Persistence.Repositories Assert.AreEqual(false, scope.Database.ExecuteScalar($"SELECT published FROM {Constants.DatabaseSchema.Tables.Document} WHERE nodeId=@id", new { id = content1.Id })); // publish = version - content1.PublishCulture(CultureType.Invariant); + content1.PublishCulture(CultureImpact.Invariant); content1.PublishedState = PublishedState.Publishing; repository.Save(content1); @@ -239,7 +239,7 @@ namespace Umbraco.Tests.Persistence.Repositories // publish = new version content1.Name = "name-4"; content1.SetValue("title", "title-4"); - content1.PublishCulture(CultureType.Invariant); + content1.PublishCulture(CultureImpact.Invariant); content1.PublishedState = PublishedState.Publishing; repository.Save(content1); @@ -654,7 +654,7 @@ namespace Umbraco.Tests.Persistence.Repositories // publish them all foreach (var content in result) { - content.PublishCulture(CultureType.Invariant); + content.PublishCulture(CultureImpact.Invariant); repository.Save(content); } diff --git a/src/Umbraco.Tests/Services/ContentServiceTagsTests.cs b/src/Umbraco.Tests/Services/ContentServiceTagsTests.cs index 274a69e53b..6b4f2942f7 100644 --- a/src/Umbraco.Tests/Services/ContentServiceTagsTests.cs +++ b/src/Umbraco.Tests/Services/ContentServiceTagsTests.cs @@ -517,7 +517,7 @@ namespace Umbraco.Tests.Services allTags = tagService.GetAllContentTags(); Assert.AreEqual(0, allTags.Count()); - content1.PublishCulture(CultureType.Invariant); + content1.PublishCulture(CultureImpact.Invariant); contentService.SaveAndPublish(content1); Assert.IsTrue(content1.Published); @@ -601,7 +601,7 @@ namespace Umbraco.Tests.Services var allTags = tagService.GetAllContentTags(); Assert.AreEqual(0, allTags.Count()); - content1.PublishCulture(CultureType.Invariant); + content1.PublishCulture(CultureImpact.Invariant); contentService.SaveAndPublish(content1); tags = tagService.GetTagsForEntity(content2.Id); diff --git a/src/Umbraco.Tests/Services/ContentServiceTests.cs b/src/Umbraco.Tests/Services/ContentServiceTests.cs index 0d906dc1f3..7d8e000879 100644 --- a/src/Umbraco.Tests/Services/ContentServiceTests.cs +++ b/src/Umbraco.Tests/Services/ContentServiceTests.cs @@ -732,8 +732,8 @@ namespace Umbraco.Tests.Services IContent content = new Content("content", Constants.System.Root, contentType); content.SetCultureName("content-fr", langFr.IsoCode); content.SetCultureName("content-en", langUk.IsoCode); - content.PublishCulture(CultureType.Explicit(langFr.IsoCode, langFr.IsDefault)); - content.PublishCulture(CultureType.Explicit(langUk.IsoCode, langUk.IsDefault)); + content.PublishCulture(CultureImpact.Explicit(langFr.IsoCode, langFr.IsDefault)); + content.PublishCulture(CultureImpact.Explicit(langUk.IsoCode, langUk.IsDefault)); Assert.IsTrue(content.IsCulturePublished(langFr.IsoCode)); Assert.IsTrue(content.IsCulturePublished(langUk.IsoCode)); @@ -1001,7 +1001,7 @@ namespace Umbraco.Tests.Services // content cannot publish values because they are invalid var propertyValidationService = new PropertyValidationService(Factory.GetInstance(), ServiceContext.DataTypeService); - var isValid = propertyValidationService.IsPropertyDataValid(content, out var invalidProperties, CultureType.Invariant); + var isValid = propertyValidationService.IsPropertyDataValid(content, out var invalidProperties, CultureImpact.Invariant); Assert.IsFalse(isValid); Assert.IsNotEmpty(invalidProperties); @@ -1036,7 +1036,7 @@ namespace Umbraco.Tests.Services content.SetCultureName("name-fr", langFr.IsoCode); content.SetCultureName("name-da", langDa.IsoCode); - content.PublishCulture(CultureType.Explicit(langFr.IsoCode, langFr.IsDefault)); + content.PublishCulture(CultureImpact.Explicit(langFr.IsoCode, langFr.IsDefault)); var result = ((ContentService)ServiceContext.ContentService).CommitDocumentChanges(content); Assert.IsTrue(result.Success); content = ServiceContext.ContentService.GetById(content.Id); @@ -1044,7 +1044,7 @@ namespace Umbraco.Tests.Services Assert.IsFalse(content.IsCulturePublished(langDa.IsoCode)); content.UnpublishCulture(langFr.IsoCode); - content.PublishCulture(CultureType.Explicit(langDa.IsoCode, langDa.IsDefault)); + content.PublishCulture(CultureImpact.Explicit(langDa.IsoCode, langDa.IsDefault)); result = ((ContentService)ServiceContext.ContentService).CommitDocumentChanges(content); Assert.IsTrue(result.Success); diff --git a/src/Umbraco.Tests/Services/PerformanceTests.cs b/src/Umbraco.Tests/Services/PerformanceTests.cs index ba4c708c22..9cf38e1789 100644 --- a/src/Umbraco.Tests/Services/PerformanceTests.cs +++ b/src/Umbraco.Tests/Services/PerformanceTests.cs @@ -216,7 +216,7 @@ namespace Umbraco.Tests.Services var result = new List(); ServiceContext.ContentTypeService.Save(contentType1); IContent lastParent = MockedContent.CreateSimpleContent(contentType1); - lastParent.PublishCulture(CultureType.Invariant); + lastParent.PublishCulture(CultureImpact.Invariant); ServiceContext.ContentService.SaveAndPublish(lastParent); result.Add(lastParent); //create 20 deep @@ -230,7 +230,7 @@ namespace Umbraco.Tests.Services //only publish evens if (j % 2 == 0) { - content.PublishCulture(CultureType.Invariant); + content.PublishCulture(CultureImpact.Invariant); ServiceContext.ContentService.SaveAndPublish(content); } else diff --git a/src/Umbraco.Tests/Services/PropertyValidationServiceTests.cs b/src/Umbraco.Tests/Services/PropertyValidationServiceTests.cs index bfca80c9b7..e1e19918ce 100644 --- a/src/Umbraco.Tests/Services/PropertyValidationServiceTests.cs +++ b/src/Umbraco.Tests/Services/PropertyValidationServiceTests.cs @@ -57,7 +57,7 @@ namespace Umbraco.Tests.Services x => x.Published == true //set to published, the default culture will validate invariant anyways && x.Properties == new PropertyCollection(new[] { p1, p2, p3, p4 })); - var result = validationService.IsPropertyDataValid(content, out var invalid, CultureType.Explicit("en-US", true)); + var result = validationService.IsPropertyDataValid(content, out var invalid, CultureImpact.Explicit("en-US", true)); Assert.IsFalse(result); Assert.AreEqual(2, invalid.Length); @@ -81,7 +81,7 @@ namespace Umbraco.Tests.Services x => x.Published == false //set to not published, the non default culture will need to validate invariant too && x.Properties == new PropertyCollection(new[] { p1, p2, p3, p4 })); - var result = validationService.IsPropertyDataValid(content, out var invalid, CultureType.Explicit("en-US", false)); + var result = validationService.IsPropertyDataValid(content, out var invalid, CultureImpact.Explicit("en-US", false)); Assert.IsFalse(result); Assert.AreEqual(2, invalid.Length); @@ -97,15 +97,15 @@ namespace Umbraco.Tests.Services var p2 = new Property(new PropertyType(dataType, "test2") { Mandatory = true, Variations = ContentVariation.Nothing }); p2.SetValue(null, null); //invalid var p3 = new Property(new PropertyType(dataType, "test3") { Mandatory = true, Variations = ContentVariation.Culture }); - p3.SetValue(null, "en-US"); //ignored because the CultureType isn't the default lang + the content is published + p3.SetValue(null, "en-US"); //ignored because the impact isn't the default lang + the content is published var p4 = new Property(new PropertyType(dataType, "test4") { Mandatory = true, Variations = ContentVariation.Nothing }); - p4.SetValue(null, null); //ignored because the CultureType isn't the default lang + the content is published + p4.SetValue(null, null); //ignored because the impact isn't the default lang + the content is published var content = Mock.Of( x => x.Published == true //set to published && x.Properties == new PropertyCollection(new[] { p1, p2, p3, p4 })); - var result = validationService.IsPropertyDataValid(content, out var invalid, CultureType.Explicit("en-US", false)); + var result = validationService.IsPropertyDataValid(content, out var invalid, CultureImpact.Explicit("en-US", false)); Assert.IsFalse(result); Assert.AreEqual(2, invalid.Length); @@ -128,7 +128,7 @@ namespace Umbraco.Tests.Services var content = Mock.Of( x => x.Properties == new PropertyCollection(new[] { p1, p2, p3, p4 })); - var result = validationService.IsPropertyDataValid(content, out var invalid, CultureType.Invariant); + var result = validationService.IsPropertyDataValid(content, out var invalid, CultureImpact.Invariant); Assert.IsFalse(result); Assert.AreEqual(2, invalid.Length); @@ -151,7 +151,7 @@ namespace Umbraco.Tests.Services var content = Mock.Of( x => x.Properties == new PropertyCollection(new[] { p1, p2, p3, p4 })); - var result = validationService.IsPropertyDataValid(content, out var invalid, CultureType.All); + var result = validationService.IsPropertyDataValid(content, out var invalid, CultureImpact.All); Assert.IsFalse(result); Assert.AreEqual(4, invalid.Length); diff --git a/src/Umbraco.Tests/Umbraco.Tests.csproj b/src/Umbraco.Tests/Umbraco.Tests.csproj index c555211d59..b6af7ea62d 100644 --- a/src/Umbraco.Tests/Umbraco.Tests.csproj +++ b/src/Umbraco.Tests/Umbraco.Tests.csproj @@ -134,7 +134,7 @@ - + diff --git a/src/Umbraco.Web/Editors/ContentController.cs b/src/Umbraco.Web/Editors/ContentController.cs index a1129e5583..d62f8ee844 100644 --- a/src/Umbraco.Web/Editors/ContentController.cs +++ b/src/Umbraco.Web/Editors/ContentController.cs @@ -1341,7 +1341,7 @@ namespace Umbraco.Web.Editors foreach (var variant in cultureVariants.Where(x => x.Publish)) { // publishing any culture, implies the invariant culture - var valid = persistentContent.PublishCulture(CultureType.Explicit(variant.Culture, IsDefaultCulture(variant.Culture))); + var valid = persistentContent.PublishCulture(CultureImpact.Explicit(variant.Culture, IsDefaultCulture(variant.Culture))); if (!valid) { AddCultureValidationError(variant.Culture, "speechBubbles/contentCultureValidationError");