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); }