/// <summary>
/// Sets the publishing values for names and properties.
/// </summary>
/// <param name="content"></param>
/// <param name="impact"></param>
/// <returns>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</returns>
public static bool PublishCulture(this IContent content, CultureImpact impact)
{
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(impact.Culture, "*", true))
{
throw new NotSupportedException($"Culture \"{impact.Culture}\" is not supported by content type \"{content.ContentType.Alias}\" with variation \"{content.ContentType.Variations}\".");
}
// 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 (impact.ImpactsOnlyInvariantCulture)
{
if (string.IsNullOrWhiteSpace(content.Name))
{
return(false);
}
// PublishName set by repository - nothing to do here
}
else if (impact.ImpactsExplicitCulture)
{
var name = content.GetCultureName(impact.Culture);
if (string.IsNullOrWhiteSpace(name))
{
return(false);
}
content.SetPublishInfo(impact.Culture, name, DateTime.Now);
}
// 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)
{
// 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);
}
}
content.PublishedState = PublishedState.Publishing;
return(true);
}
/// <summary>
/// Tries to create an impact instance representing the impact of a culture set,
/// in the context of a content item variation.
/// </summary>
/// <param name="culture">The culture code.</param>
/// <param name="isDefault">A value indicating whether the culture is the default culture.</param>
/// <param name="variation">A content variation.</param>
/// <param name="throwOnFail">A value indicating whether to throw if the impact cannot be created.</param>
/// <param name="impact">The impact if it could be created, otherwise null.</param>
/// <returns>A value indicating whether the impact could be created.</returns>
/// <remarks>
/// <para>Validates that the culture is compatible with the variation.</para>
/// </remarks>
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);
}