private object GetDefaultValue(Quantumart.QP8.BLL.Field qpField)
{
switch (qpField.ExactType)
{
case FieldExactTypes.String:
case FieldExactTypes.Textbox:
case FieldExactTypes.VisualEdit:
case FieldExactTypes.StringEnum:
case FieldExactTypes.File:
case FieldExactTypes.Image:
return(qpField.DefaultValue);
case FieldExactTypes.Boolean:
return(qpField.DefaultValue == "1" ? true : (object)null);
case FieldExactTypes.Numeric:
return(Double.TryParse(qpField.DefaultValue, out double number)
? qpField.IsInteger ? (int)number : number : (object)null);
case FieldExactTypes.Date:
case FieldExactTypes.Time:
case FieldExactTypes.DateTime:
return(DateTime.TryParse(qpField.DefaultValue, out DateTime dateTime)
? dateTime : (object)null);
case FieldExactTypes.Classifier:
return(Int32.TryParse(qpField.DefaultValue, out int contentId)
? _contentService.Read(contentId).NetName : null);
default:
return(null);
}
}
private void AddEnumElement(XmlSchemaGroupBase schema, string name, Quantumart.QP8.BLL.Field field, bool required)
{
var values = field.StringEnumItems.Select(itm => itm.Value).ToArray();
var element = new XmlSchemaElement();
var type = new XmlSchemaSimpleType();
var restriction = new XmlSchemaSimpleTypeRestriction();
element.Name = name;
element.SchemaType = type;
restriction.BaseTypeName = new XmlQualifiedName(StringType, XmlSchema.Namespace);
type.Content = restriction;
schema.Items.Add(element);
if (!required)
{
element.MinOccurs = 0;
element.MaxOccurs = 1;
}
foreach (var item in field.StringEnumItems)
{
var option = new XmlSchemaEnumerationFacet();
AddAnnotation(option, item.Alias);
option.Value = item.Value;
restriction.Facets.Add(option);
}
}
/// <exception cref="NotSupportedException" />
/// <exception cref="InvalidOperationException" />
private FieldSchema GetFieldSchema(
Field field, Quantumart.QP8.BLL.Field qpField, SchemaContext context, string path)
{
path += $"/{field?.FieldName ?? qpField.Name ?? ""}";
FieldSchema fieldSchema;
if (field == null || field is PlainField)
{
fieldSchema = GetPlainFieldSchema(qpField);
}
else if (field is EntityField entityField)
{
fieldSchema = GetRelationFieldSchema(entityField, qpField, context, path);
}
else if (field is ExtensionField extensionField)
{
fieldSchema = GetExtensionFieldSchema(extensionField, qpField, context, path);
}
else
{
throw new NotSupportedException($"Field type {field.GetType()} is not supported");
}
fieldSchema.FieldId = field?.FieldId ?? qpField.Id;
fieldSchema.FieldName = field?.FieldName ?? qpField.Name ?? "";
fieldSchema.FieldOrder = qpField.Order;
fieldSchema.FieldType = qpField.ExactType;
fieldSchema.FieldDescription = IsHtmlWhiteSpace(qpField.Description) ? "" : qpField.Description;
if (!IsHtmlWhiteSpace(field?.FieldTitle))
{
fieldSchema.FieldTitle = field.FieldTitle;
}
else if (!IsHtmlWhiteSpace(qpField.FriendlyName))
{
fieldSchema.FieldTitle = qpField.FriendlyName;
}
else
{
fieldSchema.FieldTitle = "";
}
fieldSchema.IsRequired = qpField.Required && !(field is BackwardRelationField);
fieldSchema.IsReadOnly = qpField.ReadOnly;
fieldSchema.ViewInList = qpField.ViewInList;
fieldSchema.DefaultValue = GetDefaultValue(qpField);
return(fieldSchema);
}
private PlainFieldSchema GetPlainFieldSchema(Quantumart.QP8.BLL.Field qpField)
{
switch (qpField.ExactType)
{
case FieldExactTypes.String:
return(new StringFieldSchema {
RegexPattern = qpField.InputMask
});
case FieldExactTypes.Numeric:
return(new NumericFieldSchema {
IsInteger = qpField.IsInteger
});
case FieldExactTypes.Classifier:
return(new ClassifierFieldSchema {
Changeable = qpField.Changeable
});
case FieldExactTypes.File:
case FieldExactTypes.Image:
return(new FileFieldSchema
{
UseSiteLibrary = qpField.UseSiteLibrary,
SubFolder = qpField.SubFolder,
LibraryEntityId = qpField.LibraryEntityId,
LibraryParentEntityId = qpField.LibraryParentEntityId
// FolderUrl = _dbConnector.GetUrlForFileAttribute(qpField.Id, true, true)
});
case FieldExactTypes.StringEnum:
return(new EnumFieldSchema
{
ShowAsRadioButtons = qpField.ShowAsRadioButtons,
Items = qpField.StringEnumItems.ToArray()
});
// TODO: other plain field types
default:
return(new PlainFieldSchema());
}
}
private XmlQualifiedName GetElementType(Quantumart.QP8.BLL.Field field)
{
string typeName = field.Type.Name;
if (field.IsClassifier)
{
return(new XmlQualifiedName(StringType, XmlSchema.Namespace));
}
if (typeName == "File")
{
return(new XmlQualifiedName("File"));
}
if (typeName == "Boolean")
{
return(new XmlQualifiedName(BooleanType, XmlSchema.Namespace));
}
if (typeName == "Numeric")
{
if (field.Size == 0)
{
return(new XmlQualifiedName(IntegerType, XmlSchema.Namespace));
}
else
{
return(new XmlQualifiedName(DecimalType, XmlSchema.Namespace));
}
}
if (typeName == "DateTime")
{
return(new XmlQualifiedName(DateTimeType, XmlSchema.Namespace));
}
if (typeName == "Date")
{
return(new XmlQualifiedName(DateType, XmlSchema.Namespace));
}
else
{
return(new XmlQualifiedName(StringType, XmlSchema.Namespace));
}
}
/// <exception cref="NotSupportedException" />
/// <exception cref="InvalidOperationException" />
private FieldSchema GetExtensionFieldSchema(
ExtensionField extensionField, Quantumart.QP8.BLL.Field qpField, SchemaContext context, string path)
{
var contentSchemas = new Dictionary <string, IContentSchema>();
foreach (Content content in extensionField.ContentMapping.Values)
{
var qpContent = _contentService.Read(content.ContentId);
if (!String.IsNullOrEmpty(qpContent.NetName) &&
!contentSchemas.ContainsKey(qpContent.NetName))
{
var contentSchema = GetContentSchema(content, context, $"{path}/{qpContent.NetName}");
contentSchema.ForExtension = true;
contentSchemas[qpContent.NetName] = contentSchema;
}
}
return(new ExtensionFieldSchema
{
Changeable = qpField.Changeable,
ExtensionContents = contentSchemas
});
}
/// <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");
}
