private static void ContextualizeVariation(
this IVariationContextAccessor variationContextAccessor,
ContentVariation variations,
int?contentId,
ref string?culture,
ref string?segment)
{
if (culture != null && segment != null)
{
return;
}
// use context values
VariationContext?publishedVariationContext = variationContextAccessor?.VariationContext;
if (culture == null)
{
culture = variations.VariesByCulture() ? publishedVariationContext?.Culture : string.Empty;
}
if (segment == null)
{
if (variations.VariesBySegment())
{
segment = contentId == null
? publishedVariationContext?.Segment
: publishedVariationContext?.GetSegment(contentId.Value);
}
else
{
segment = string.Empty;
}
}
}
/// <summary>
/// Validates that a combination of culture and segment is valid for the variation.
/// </summary>
/// <param name="variation">The variation.</param>
/// <param name="culture">The culture.</param>
/// <param name="segment">The segment.</param>
/// <param name="exact">A value indicating whether to perform exact validation.</param>
/// <param name="wildcards">A value indicating whether to support wildcards.</param>
/// <param name="throwIfInvalid">A value indicating whether to throw a <see cref="NotSupportedException"/> when the combination is invalid.</param>
/// <returns>True if the combination is valid; otherwise false.</returns>
/// <remarks>
/// <para>When validation is exact, the combination must match the variation exactly. For instance, if the variation is Culture, then
/// a culture is required. When validation is not strict, the combination must be equivalent, or more restrictive: if the variation is
/// Culture, an invariant combination is ok.</para>
/// <para>Basically, exact is for one content type, or one property type, and !exact is for "all property types" of one content type.</para>
/// <para>Both <paramref name="culture"/> and <paramref name="segment"/> can be "*" to indicate "all of them".</para>
/// </remarks>
/// <exception cref="NotSupportedException">Occurs when the combination is invalid, and <paramref name="throwIfInvalid"/> is true.</exception>
public static bool ValidateVariation(this ContentVariation variation, string culture, string segment, bool exact, bool wildcards, bool throwIfInvalid)
{
culture = culture.NullOrWhiteSpaceAsNull();
segment = segment.NullOrWhiteSpaceAsNull();
// if wildcards are disabled, do not allow "*"
if (!wildcards && (culture == "*" || segment == "*"))
{
if (throwIfInvalid)
{
throw new NotSupportedException($"Variation wildcards are not supported.");
}
return(false);
}
if (variation.VariesByCulture())
{
// varies by culture
// in exact mode, the culture cannot be null
if (exact && culture == null)
{
if (throwIfInvalid)
{
throw new NotSupportedException($"Culture may not be null because culture variation is enabled.");
}
return(false);
}
}
else
{
// does not vary by culture
// the culture cannot have a value
// unless wildcards and it's "*"
if (culture != null && !(wildcards && culture == "*"))
{
if (throwIfInvalid)
{
throw new NotSupportedException($"Culture \"{culture}\" is invalid because culture variation is disabled.");
}
return(false);
}
}
// if it does not vary by segment
// the segment cannot have a value
// segment may always be null, even when the ContentVariation.Segment flag is set for this variation,
// therefore the exact parameter is not used in segment validation.
if (!variation.VariesBySegment() && segment != null && !(wildcards && segment == "*"))
{
if (throwIfInvalid)
{
throw new NotSupportedException($"Segment \"{segment}\" is invalid because segment variation is disabled.");
}
return(false);
}
return(true);
}
/// <summary>
/// Validates that a combination of culture and segment is valid for the variation.
/// </summary>
/// <param name="variation">The variation.</param>
/// <param name="culture">The culture.</param>
/// <param name="segment">The segment.</param>
/// <param name="exact">A value indicating whether to perform exact validation.</param>
/// <param name="wildcards">A value indicating whether to support wildcards.</param>
/// <param name="throwIfInvalid">A value indicating whether to throw a <see cref="NotSupportedException"/> when the combination is invalid.</param>
/// <returns>True if the combination is valid; otherwise false.</returns>
/// <remarks>
/// <para>When validation is exact, the combination must match the variation exactly. For instance, if the variation is Culture, then
/// a culture is required. When validation is not strict, the combination must be equivalent, or more restrictive: if the variation is
/// Culture, an invariant combination is ok.</para>
/// <para>Basically, exact is for one content type, or one property type, and !exact is for "all property types" of one content type.</para>
/// <para>Both <paramref name="culture"/> and <paramref name="segment"/> can be "*" to indicate "all of them".</para>
/// </remarks>
/// <exception cref="NotSupportedException">Occurs when the combination is invalid, and <paramref name="throwIfInvalid"/> is true.</exception>
public static bool ValidateVariation(this ContentVariation variation, string culture, string segment, bool exact, bool wildcards, bool throwIfInvalid)
{
culture = culture.NullOrWhiteSpaceAsNull();
segment = segment.NullOrWhiteSpaceAsNull();
bool Validate(bool variesBy, string value)
{
if (variesBy)
{
// varies by
// in exact mode, the value cannot be null (but it can be a wildcard)
// in !wildcards mode, the value cannot be a wildcard (but it can be null)
if ((exact && value == null) || (!wildcards && value == "*"))
{
return(false);
}
}
else
{
// does not vary by value
// the value cannot have a value
// unless wildcards and it's "*"
if (value != null && (!wildcards || value != "*"))
{
return(false);
}
}
return(true);
}
if (!Validate(variation.VariesByCulture(), culture))
{
if (throwIfInvalid)
{
throw new NotSupportedException($"Culture value \"{culture ?? "<null>"}\" is invalid.");
}
return(false);
}
if (!Validate(variation.VariesBySegment(), segment))
{
if (throwIfInvalid)
{
throw new NotSupportedException($"Segment value \"{segment ?? "<null>"}\" is invalid.");
}
return(false);
}
return(true);
}
public static void ContextualizeVariation(this IVariationContextAccessor variationContextAccessor, ContentVariation variations, ref string culture, ref string segment)
{
if (culture != null && segment != null)
{
return;
}
// use context values
var publishedVariationContext = variationContextAccessor?.VariationContext;
if (culture == null)
{
culture = variations.VariesByCulture() ? publishedVariationContext?.Culture : "";
}
if (segment == null)
{
segment = variations.VariesBySegment() ? publishedVariationContext?.Segment : "";
}
}
