private void CompareArticleField(ArticleField dbField, ArticleField tntField, string path)
{
Assert.That(dbField.ContentId, Is.EqualTo(tntField.ContentId), $"{path}_ContentId");
Assert.That(dbField.FieldId, Is.EqualTo(tntField.FieldId), $"{path}_FieldId");
Assert.That(dbField.FieldName, Is.EqualTo(tntField.FieldName), $"{path}_FieldName");
Assert.That(dbField.FieldDisplayName, Is.EqualTo(tntField.FieldDisplayName), $"{path}_FieldDisplayName");
}
/// <exception cref="NotSupportedException" />
private object ConvertField(ArticleField field, IArticleFilter filter)
{
if (field is PlainArticleField plainArticleField)
{
return GetPlainArticleFieldValue(plainArticleField);
}
if (field is SingleArticleField singleArticleField)
{
return ConvertArticle(singleArticleField.GetItem(filter), filter);
}
if (field is MultiArticleField multiArticleField)
{
var articles = multiArticleField
.GetArticlesSorted(filter)
.Select(x => ConvertArticle(x, filter))
.ToArray();
return articles.Length == 0 ? null : articles;
}
if (field is VirtualArticleField virtualArticleField)
{
return virtualArticleField.Fields
.Select(x => new { fieldName = x.FieldName, value = ConvertField(x, filter) })
.ToDictionary(x => x.fieldName, x => x.value);
}
if (field is VirtualMultiArticleField virtualMultiArticleField)
{
return virtualMultiArticleField.VirtualArticles.Select(x => ConvertField(x, filter));
}
throw new NotSupportedException($"Field type {field.GetType()} is not supported");
}
private object Convert(ArticleField articleField, CallContext ctx)
{
if (articleField is ExtensionArticleField)
{
var extField = (ExtensionArticleField)articleField;
if (extField.GetItem(ctx.Filter) == null)
{
return(null);
}
return(ConvertValue(extField, ctx));
}
if (articleField is SingleArticleField && ((SingleArticleField)articleField).GetItem(ctx.Filter) == null)
{
return(null);
}
if (articleField is MultiArticleField && !((MultiArticleField)articleField).GetArticlesSorted(ctx.Filter).Any())
{
return(null);
}
return(new XElement(articleField.FieldName, (
articleField is PlainArticleField
? ConvertValue((PlainArticleField)articleField, ctx)
: (articleField is SingleArticleField
? ConvertValue((SingleArticleField)articleField, ctx)
: (articleField is MultiArticleField ? ConvertValue((MultiArticleField)articleField, ctx) : null)))));
}
/// <exception cref="InvalidOperationException" />
/// <exception cref="NotSupportedException" />
private void PopulateField(ArticleObject dict, ArticleField field, ArticleContext context)
{
if (field is ExtensionArticleField extensionArticleField)
{
PopulateExtensionFields(dict, extensionArticleField, context);
}
else if (field is MultiArticleField multiArticleField)
{
dict[field.FieldName] = multiArticleField
.GetArticles(context.Filter)
.Select(f => ConvertArticle(f, context))
.Where(a => a != null)
.ToArray();
}
else if (field is SingleArticleField singleArticleField)
{
dict[field.FieldName] = ConvertArticle(singleArticleField.GetItem(context.Filter), context);
}
else if (field is PlainArticleField plainArticleField)
{
dict[field.FieldName] = ConvertPlainField(plainArticleField);
}
else
{
throw new NotSupportedException($"Field with type {field.GetType()} is not supported");
}
}
private void UpdateField(ArticleField field, JToken fieldToken)
{
field.FieldId = fieldToken.Value <int>("FieldId");
field.FieldName = fieldToken.Value <string>("FieldName");
field.FieldDisplayName = fieldToken.Value <string>("FieldName");
field.CustomProperties = fieldToken["CustomProperties"]
.Children()
.OfType <JProperty>()
.Where(p => p.Value is JValue)
.ToDictionary(p => p.Name, p => ((JValue)p.Value).Value);
}
private bool GetBoolProperty(ArticleField article, string propertyKey)
{
object value;
if (article.CustomProperties != null && article.CustomProperties.TryGetValue(propertyKey, out value))
{
if (value is bool)
{
return((bool)value);
}
}
return(false);
}
public bool ShouldIncludeField(ArticleField field)
{
switch (field)
{
case VirtualArticleField _:
case VirtualMultiArticleField _:
return(false);
case PlainArticleField plainField:
return(plainField.PlainFieldType != PlainFieldType.DynamicImage);
default:
return(true);
}
}
private IEnumerable <Article> GetChildArticles(ArticleField field, IArticleFilter filter)
{
if (field is IGetArticle getArticle)
{
Article childArticle = getArticle.GetItem(filter);
return(childArticle != null ? new[] { childArticle } : new Article[0]);
}
else if (field is IGetArticles getArticles)
{
return(getArticles.GetArticles(filter));
}
else
{
return(new Article[0]);
}
}
private static string ConvertType(ArticleField field)
{
switch (field.Type)
{
case DataType.Number:
return("number");
case DataType.Bool:
return("boolean");
case DataType.SingleValue:
case DataType.MultiValue:
return("object");
default:
return("string");
}
}
private static string ConvertFormat(ArticleField field)
{
switch (field.Type)
{
case DataType.Text:
return("string");
case DataType.Number:
return("double");
case DataType.Bool:
return("boolean");
case DataType.Date:
return("date");
case DataType.DateTime:
return("date-time");
default:
return(null);
}
}
private static string ConvertType(ArticleField field)
{
switch (field.Type)
{
case DataType.Number:
return "number";
case DataType.Bool:
return "boolean";
case DataType.SingleValue:
case DataType.MultiValue:
return "object";
default:
return "string";
}
}
private static string ConvertFormat(ArticleField field)
{
switch (field.Type)
{
case DataType.Text:
return "string";
case DataType.Number:
return "double";
case DataType.Bool:
return "boolean";
case DataType.Date:
return "date";
case DataType.DateTime:
return "date-time";
default:
return null;
}
}
private ArticleField CloneField(ArticleField field, string fieldName, Dictionary <Article, Article> articleMap)
{
var pField = field as PlainArticleField;
var sField = field as SingleArticleField;
var mField = field as MultiArticleField;
var eField = field as ExtensionArticleField;
var bField = field as BackwardArticleField;
var vField = field as VirtualArticleField;
var vmField = field as VirtualMultiArticleField;
ArticleField clonnedField;
if (pField != null)
{
clonnedField = new PlainArticleField
{
NativeValue = pField.NativeValue,
Value = pField.Value,
PlainFieldType = pField.PlainFieldType
};
}
else if (eField != null)
{
clonnedField = new ExtensionArticleField
{
Aggregated = eField.Aggregated,
SubContentId = eField.SubContentId,
Item = eField.Item == null ? null : articleMap[eField.Item],
Value = eField.Value
};
}
else if (sField != null)
{
clonnedField = new SingleArticleField
{
Aggregated = sField.Aggregated,
SubContentId = sField.SubContentId,
Item = sField.Item == null ? null : articleMap[sField.Item]
};
}
else if (bField != null)
{
clonnedField = new BackwardArticleField
{
SubContentId = bField.SubContentId,
Items = bField.Items.ToDictionary(itm => itm.Key, itm => articleMap[itm.Value]),
RelationGroupName = bField.RelationGroupName
};
}
else if (mField != null)
{
clonnedField = new MultiArticleField
{
SubContentId = mField.SubContentId,
Items = mField.Items.ToDictionary(itm => itm.Key, itm => articleMap[itm.Value])
};
}
else if (vField != null)
{
clonnedField = new VirtualArticleField
{
Fields = vField.Fields
};
}
else if (vmField != null)
{
clonnedField = new VirtualMultiArticleField
{
VirtualArticles = vmField.VirtualArticles
.Select(f => CloneField(f, fieldName, articleMap) as VirtualArticleField)
.ToArray()
};
}
else
{
throw new Exception($"Cant't process field {field.FieldName} for localization");
}
clonnedField.FieldName = fieldName;
clonnedField.ContentId = field.ContentId;
clonnedField.FieldId = field.FieldId;
clonnedField.CustomProperties = field.CustomProperties;
clonnedField.FieldDisplayName = field.FieldDisplayName;
return(clonnedField);
}
