/// <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");
}
}
/// <exception cref="InvalidOperationException" />
private void PopulateExtensionFields(
ArticleObject dict, ExtensionArticleField field, ArticleContext context)
{
if (field.Item == null)
{
return;
}
Article article = field.Item;
dict[field.FieldName] = article.ContentName;
dict[ArticleObject._Extension(field.FieldName)] = new ExtensionFieldObject
{
[article.ContentName] = ConvertArticle(article, context, forExtension: true)
};
}
/// <exception cref="InvalidOperationException" />
/// <exception cref="NotSupportedException" />
private ArticleObject ConvertArticle(Article article, ArticleContext context, bool forExtension = false)
{
if (!context.ShouldIncludeArticle(article))
{
return(null);
}
var dict = new ArticleObject
{
[ArticleObject._ServerId] = article.Id,
};
if (forExtension)
{
dict[ArticleObject._IsExtension] = true;
}
else if (context.Visited.Contains(article))
{
return(dict);
}
else
{
context.Visited.Add(article);
}
if (!article.IsReadOnly)
{
dict[ArticleObject._Modified] = article.Modified == default(DateTime)
? article.Created
: article.Modified;
}
foreach (ArticleField field in article)
{
if (context.ShouldIncludeField(field))
{
PopulateField(dict, field, context);
}
}
return(dict);
}
/// <exception cref="NotSupportedException" />
/// <exception cref="InvalidOperationException" />
private RelationFieldSchema GetRelationFieldSchema(
EntityField entityField, Quantumart.QP8.BLL.Field qpField, SchemaContext context, string path)
{
ContentSchema contentSchema = GetContentSchema(entityField.Content, context, path);
string relationCondition = _editorPreloadingService.GetRelationCondition(entityField, qpField);
ArticleObject[] preloadedArticles = new ArticleObject[0];
if (entityField.PreloadingMode == PreloadingMode.Eager)
{
preloadedArticles = _editorPreloadingService.PreloadRelationArticles(
entityField,
relationCondition,
context.VisitedPreloadedArticles,
context.Dictionaries);
}
string[] displayFieldNames = contentSchema.Fields.Values
.OfType <PlainFieldSchema>()
.Where(f => f.FieldType != FieldExactTypes.Textbox && f.FieldType != FieldExactTypes.VisualEdit)
.OrderByDescending(f => f.ViewInList)
.ThenBy(f => f.FieldOrder)
.Take(Math.Max(qpField.ListFieldTitleCount, 1))
.Select(f => f.FieldName)
.ToArray();
if (qpField.ExactType == FieldExactTypes.O2MRelation && !(entityField is BackwardRelationField) ||
qpField.ExactType == FieldExactTypes.M2ORelation && entityField is BackwardRelationField)
{
return(new SingleRelationFieldSchema
{
RelatedContent = contentSchema,
UpdatingMode = entityField.UpdatingMode,
IsDpcBackwardField = entityField is BackwardRelationField,
RelationCondition = relationCondition,
DisplayFieldNames = displayFieldNames,
PreloadingMode = entityField.PreloadingMode,
PreloadedArticles = preloadedArticles,
});
}
if (qpField.ExactType == FieldExactTypes.M2MRelation ||
qpField.ExactType == FieldExactTypes.O2MRelation && entityField is BackwardRelationField ||
qpField.ExactType == FieldExactTypes.M2ORelation && !(entityField is BackwardRelationField))
{
int? orderFieldId = qpField.TreeOrderFieldId ?? qpField.ListOrderFieldId ?? qpField.OrderFieldId;
bool orderByTitle = qpField.TreeOrderByTitle || qpField.ListOrderByTitle || qpField.OrderByTitle;
string orderByFieldName = contentSchema.Fields.Values
.OfType <PlainFieldSchema>()
.Where(f => f.FieldId == orderFieldId)
.Select(f => f.FieldName)
.FirstOrDefault();
if (orderByFieldName == null && orderByTitle)
{
orderByFieldName = displayFieldNames.FirstOrDefault();
}
int?maxDataListItemCount = null;
if (qpField.ExactType == FieldExactTypes.M2ORelation && qpField.BackRelationId != null)
{
// MaxDataListItemCount лежит в соотв. поле O2MRelation
var reverseField = _fieldService.Read(qpField.BackRelationId.Value);
if (reverseField.MaxDataListItemCount > 0)
{
maxDataListItemCount = reverseField.MaxDataListItemCount;
}
}
else if (qpField.MaxDataListItemCount > 0)
{
maxDataListItemCount = qpField.MaxDataListItemCount;
}
return(new MultiRelationFieldSchema
{
RelatedContent = contentSchema,
UpdatingMode = entityField.UpdatingMode,
IsDpcBackwardField = entityField is BackwardRelationField,
RelationCondition = relationCondition,
DisplayFieldNames = displayFieldNames,
OrderByFieldName = orderByFieldName,
MaxDataListItemCount = maxDataListItemCount,
PreloadingMode = entityField.PreloadingMode,
PreloadedArticles = preloadedArticles,
});
}
throw new NotSupportedException($"Relation type {qpField.ExactType} is not supported");
}
