public static FieldConverter ExcludeChangedTypes()
{
return((data, field) =>
{
foreach (var value in data.Values)
{
if (value.Type == JsonValueType.Null)
{
continue;
}
try
{
var(_, error) = JsonValueConverter.ConvertValue(field, value);
if (error != null)
{
return null;
}
}
catch
{
return null;
}
}
return data;
});
}
public async Task ValidateAsync(object value, ValidationContext context, AddError addError)
{
try
{
object typedValue = null;
if (value is JToken jToken)
{
typedValue = jToken.IsNull() ? null : JsonValueConverter.ConvertValue(field, jToken);
}
var tasks = new List <Task>();
foreach (var validator in validators)
{
tasks.Add(validator.ValidateAsync(typedValue, context, addError));
}
await Task.WhenAll(tasks);
}
catch
{
addError(context.Path, "Not a valid value.");
}
}
public async Task ValidateAsync(object value, ValidationContext context, AddError addError)
{
try
{
var typedValue = value;
if (value is IJsonValue jsonValue)
{
if (jsonValue.Type == JsonValueType.Null)
{
typedValue = null;
}
else
{
typedValue = JsonValueConverter.ConvertValue(field, jsonValue);
}
}
if (validators?.Length > 0)
{
var tasks = new List <Task>();
foreach (var validator in validators)
{
tasks.Add(validator.ValidateAsync(typedValue, context, addError));
}
await Task.WhenAll(tasks);
}
}
catch
{
addError(context.Path, "Not a valid value.");
}
}
public static ValueConverter ExcludeChangedTypes(IJsonSerializer jsonSerializer)
{
return((value, field, parent) =>
{
if (value.Type == JsonValueType.Null)
{
return value;
}
try
{
var(_, error) = JsonValueConverter.ConvertValue(field, value, jsonSerializer);
if (error != null)
{
return null;
}
}
catch
{
return null;
}
return value;
});
}
public static ValueConverter ExcludeChangedTypes()
{
return((value, field) =>
{
if (value.Type == JsonValueType.Null)
{
return value;
}
try
{
var(_, error) = JsonValueConverter.ConvertValue(field, value);
if (error != null)
{
return Value.Unset;
}
}
catch
{
return Value.Unset;
}
return value;
});
}
public static FieldConverter ExcludeChangedTypes()
{
return((data, field) =>
{
var isValid = true;
foreach (var value in data.Values)
{
try
{
if (!value.IsNull())
{
JsonValueConverter.ConvertValue(field, value);
}
}
catch
{
isValid = false;
break;
}
}
if (!isValid)
{
return null;
}
return data;
});
}
public async ValueTask ValidateAsync(object?value, ValidationContext context, AddError addError)
{
var typedValue = value;
try
{
if (value is IJsonValue jsonValue)
{
if (jsonValue.Type == JsonValueType.Null)
{
typedValue = null;
}
else
{
var(json, error) = JsonValueConverter.ConvertValue(field, jsonValue, context.JsonSerializer, context.Components);
if (error != null)
{
addError(context.Path, error.Error);
}
else
{
typedValue = json;
}
}
}
}
catch
{
addError(context.Path, T.Get("contents.validation.invalid"));
return;
}
await validator.ValidateAsync(typedValue, context, addError);
}
public async Task ValidateAsync(object?value, ValidationContext context, AddError addError)
{
var typedValue = value;
try
{
if (value is IJsonValue jsonValue)
{
if (jsonValue.Type == JsonValueType.Null)
{
typedValue = null;
}
else
{
var(json, error) = JsonValueConverter.ConvertValue(field, jsonValue);
if (error != null)
{
addError(context.Path, error.Error);
}
else
{
typedValue = json;
}
}
}
}
catch
{
addError(context.Path, T.Get("contents.validation.invalid"));
return;
}
if (validators?.Length > 0)
{
var tasks = new List <Task>();
foreach (var validator in validators)
{
tasks.Add(validator.ValidateAsync(typedValue, context, addError));
}
await Task.WhenAll(tasks);
}
}
public static ValueConverter ExcludeChangedTypes()
{
return((value, field) =>
{
if (value.IsNull())
{
return value;
}
try
{
JsonValueConverter.ConvertValue(field, value);
}
catch
{
return Value.Unset;
}
return value;
});
}
public static FieldConverter ExcludeChangedTypes()
{
return((data, field) =>
{
foreach (var value in data.Values)
{
if (value.IsNull())
{
continue;
}
try
{
JsonValueConverter.ConvertValue(field, value);
}
catch
{
return null;
}
}
return data;
});
}
public static NamedContentData ToApiModel(this NamedContentData content, Schema schema, LanguagesConfig languagesConfig, bool excludeHidden = true, bool checkTypeCompatibility = false)
{
Guard.NotNull(schema, nameof(schema));
Guard.NotNull(languagesConfig, nameof(languagesConfig));
var codeForInvariant = InvariantPartitioning.Instance.Master.Key;
var codeForMasterLanguage = languagesConfig.Master.Language.Iso2Code;
var result = new NamedContentData();
foreach (var fieldValue in content)
{
if (!schema.FieldsByName.TryGetValue(fieldValue.Key, out var field) || (excludeHidden && field.IsHidden))
{
continue;
}
if (checkTypeCompatibility)
{
var isValid = true;
foreach (var value in fieldValue.Value.Values)
{
try
{
if (!value.IsNull())
{
JsonValueConverter.ConvertValue(field, value);
}
}
catch
{
isValid = false;
break;
}
}
if (!isValid)
{
continue;
}
}
var fieldResult = new ContentFieldData();
var fieldValues = fieldValue.Value;
if (field.Partitioning.Equals(Partitioning.Language))
{
foreach (var languageConfig in languagesConfig)
{
var languageCode = languageConfig.Key;
if (fieldValues.TryGetValue(languageCode, out var value))
{
fieldResult.Add(languageCode, value);
}
else if (languageConfig == languagesConfig.Master && fieldValues.TryGetValue(codeForInvariant, out value))
{
fieldResult.Add(languageCode, value);
}
}
}
else
{
if (fieldValues.TryGetValue(codeForInvariant, out var value))
{
fieldResult.Add(codeForInvariant, value);
}
else if (fieldValues.TryGetValue(codeForMasterLanguage, out value))
{
fieldResult.Add(codeForInvariant, value);
}
else if (fieldValues.Count > 0)
{
fieldResult.Add(codeForInvariant, fieldValues.Values.First());
}
}
result.Add(field.Name, fieldResult);
}
return(result);
}