private JSchema AttachFieldData(Quantumart.QP8.BLL.Field qpField, JSchema schema) { schema.Description = !IsHtmlWhiteSpace(qpField.Description) ? qpField.Description : !IsHtmlWhiteSpace(qpField.FriendlyName) ? qpField.FriendlyName : schema.Description; switch (qpField.ExactType) { case FieldExactTypes.StringEnum: foreach (var item in qpField.StringEnumItems.Where(item => !item.Invalid)) { schema.Enum.Add(item.Value); if (item.IsDefault.GetValueOrDefault()) { schema.Default = item.Value; } } break; } return schema; }
public DefinitionTreeNode(Quantumart.QP8.BLL.Field fieldNotInDef, string parentPath, string ownPath, bool notInDefinition, bool isFromRelatedContent, IFieldService fieldService) { Id = ownPath ?? parentPath + Separator + fieldNotInDef.Id; text = fieldNotInDef.Name; using (fieldService.CreateQpConnectionScope()) { if (isFromRelatedContent) { if (!fieldNotInDef.Aggregated) { text += " из контента " + fieldNotInDef.Content.Name; } } } expanded = false; //ноды которые не включены в описание не надо позволять раскрывать пока их не включат hasChildren = false; NotInDefinition = notInDefinition; MissingInQp = false; if (fieldNotInDef.RelationType != RelationType.None || fieldNotInDef.IsClassifier) { imageUrl = "images/icons/relation.gif"; IconName = "link"; } }
private ArticleField DeserializeField(Field fieldInDef, Quantumart.QP8.BLL.Field qpField, IProductDataSource productDataSource, DBConnector connector, Context context) { ArticleField field; if (fieldInDef is BackwardRelationField) { field = DeserializeBackwardField((BackwardRelationField)fieldInDef, productDataSource, connector, context); } else if (fieldInDef is EntityField) { field = DeserializeEntityField((EntityField)fieldInDef, qpField, productDataSource, connector, context); } else if (fieldInDef is ExtensionField) { field = DeserializeExtensionField((ExtensionField)fieldInDef, qpField, productDataSource, connector, context); } else if (fieldInDef is PlainField) { field = DeserializePlainField(qpField, productDataSource, connector); } else { throw new Exception("Неподдерживаемый тип поля: " + fieldInDef.GetType().Name); } field.ContentId = qpField.ContentId; field.FieldId = qpField.Id; field.FieldName = string.IsNullOrEmpty(fieldInDef.FieldName) ? qpField.Name : fieldInDef.FieldName; field.FieldDisplayName = qpField.DisplayName; return(field); }
private JSchema GetPlainFieldSchema(Quantumart.QP8.BLL.Field qpField) { var schema = new JSchema(); switch (qpField.ExactType) { case FieldExactTypes.Numeric: schema.Type = qpField.IsInteger ? JSchemaType.Integer : JSchemaType.Number; break; case FieldExactTypes.File: schema.Type = JSchemaType.Object; schema.AllowAdditionalProperties = false; schema.Required.Add("Name"); schema.Required.Add("AbsoluteUrl"); schema.Required.Add("FileSizeBytes"); schema.Properties["Name"] = new JSchema { Type = JSchemaType.String }; schema.Properties["AbsoluteUrl"] = new JSchema { Type = JSchemaType.String }; schema.Properties["FileSizeBytes"] = new JSchema { Type = JSchemaType.Integer, Minimum = 0, ExclusiveMinimum = false }; break; case FieldExactTypes.Boolean: schema.Type = JSchemaType.Boolean; break; case FieldExactTypes.O2MRelation: schema.Type = JSchemaType.Integer; break; default: schema.Type = JSchemaType.String; break; } return AttachFieldData(qpField, schema); }
/// <param name="qpField">Can be null</param> /// <exception cref="NotSupportedException" /> /// <exception cref="InvalidOperationException" /> private JSchema GetFieldSchema( Field field, Quantumart.QP8.BLL.Field qpField, SchemaContext context, bool forList) { if (qpField == null && !(field is BaseVirtualField)) { qpField = _fieldService.Read(field.FieldId); } if (field is PlainField) { return GetPlainFieldSchema(qpField); } else if (field is BackwardRelationField backwardRelationalField) { JSchema backwardItemSchema = GetSchemaRecursive(backwardRelationalField.Content, context, forList); return AttachFieldData(qpField, new JSchema { Type = JSchemaType.Array, Items = { backwardItemSchema } }); } else if (field is EntityField entityField) { Content fieldContent = entityField.Content; if (qpField.RelationType == Quantumart.QP8.BLL.RelationType.OneToMany) { return AttachFieldData(qpField, GetSchemaRecursive(fieldContent, context, forList)); } else { JSchema arrayItemSchema = GetSchemaRecursive(fieldContent, context, forList); return AttachFieldData(qpField, new JSchema { Type = JSchemaType.Array, Items = { arrayItemSchema } }); } } else { throw new NotSupportedException($"Field type {field.GetType()} is not supported"); } }
private ArticleField DeserializeExtensionField(ExtensionField fieldInDef, Quantumart.QP8.BLL.Field qpField, IProductDataSource productDataSource, DBConnector connector, Context context) { var extensionArticleField = new ExtensionArticleField(); string fieldName = string.IsNullOrEmpty(fieldInDef.FieldName) ? qpField.Name : fieldInDef.FieldName; string contentName = productDataSource.GetString(fieldName); if (!string.IsNullOrEmpty(contentName)) { Models.Configuration.Content valueDef = fieldInDef.ContentMapping.Values.FirstOrDefault(x => _contentService.Read(x.ContentId).NetName == contentName); if (valueDef == null) { throw new Exception( $"'{contentName}' value is not found in an available extension content list, id = {fieldInDef.FieldId}"); } extensionArticleField.Value = valueDef.ContentId.ToString(); extensionArticleField.SubContentId = valueDef.ContentId; IProductDataSource extensionDataSource = productDataSource.GetExtensionContainer(fieldName, contentName); extensionArticleField.Item = DeserializeArticle(extensionDataSource, valueDef, connector, context); if (extensionArticleField.Item.Id == productDataSource.GetArticleId()) { var id = GetExtensionId(connector, valueDef.ContentId, fieldInDef.FieldId, extensionArticleField.Item.Id); if (id.HasValue) { extensionArticleField.Item.Id = id.Value; } else { context.AddExtensionArticle(extensionArticleField.Item.Id, extensionArticleField.Item); extensionArticleField.Item.Id = default(int); } } } return(extensionArticleField); }
private ArticleField DeserializeEntityField(EntityField fieldInDef, Quantumart.QP8.BLL.Field qpField, IProductDataSource productDataSource, DBConnector connector, Context context) { string fieldName = fieldInDef.FieldName ?? qpField.Name; ArticleField articleField; if (qpField.RelationType == RelationType.OneToMany) { articleField = new SingleArticleField { Item = DeserializeArticle(productDataSource.GetContainer(fieldName), fieldInDef.Content, connector, context), Aggregated = qpField.Aggregated, SubContentId = fieldInDef.Content.ContentId }; } else if (qpField.RelationType == RelationType.ManyToMany || qpField.RelationType == RelationType.ManyToOne) { var multiArticleField = new MultiArticleField { SubContentId = fieldInDef.Content.ContentId }; var containersCollection = productDataSource.GetContainersCollection(fieldName); if (containersCollection != null) { foreach (Article article in containersCollection.Select(x => DeserializeArticle(x, fieldInDef.Content, connector, context))) { multiArticleField.Items.Add(article.Id, article); } } articleField = multiArticleField; } else { throw new Exception(string.Format("Field definition id={0} has EntityField type but its RelationType is not valid", fieldInDef.FieldId)); } return(articleField); }
/// <exception cref="NotSupportedException" /> /// <exception cref="InvalidOperationException" /> private void MergeExtensionFieldSchema( ExtensionField field, Quantumart.QP8.BLL.Field qpField, JSchema contentSchema, SchemaContext context) { JSchema extensionSchema = AttachFieldData(qpField, new JSchema { Type = JSchemaType.String }); foreach (Content content in field.ContentMapping.Values) { var qpContent = _contentService.Read(content.ContentId); if (!String.IsNullOrWhiteSpace(qpContent.NetName)) { extensionSchema.Enum.Add(qpContent.NetName); } } contentSchema.Properties.Add(field.FieldName, extensionSchema); var fieldGroups = field.ContentMapping.Values .SelectMany(extContent => { var fields = extContent.Fields .Select(extField => new { extField.FieldName, FieldSchema = GetFieldSchema( extField, _fieldService.Read(extField.FieldId), context, false) }); if (extContent.LoadAllPlainFields) { var qpFields = _fieldService.List(extContent.ContentId).ToArray(); var fieldsToAdd = qpFields .Where(f => f.RelationType == Quantumart.QP8.BLL.RelationType.None && extContent.Fields.All(y => y.FieldId != f.Id)) .Where(f => !context.IgnoredFields .Any(t => t.Item1.Equals(extContent) && t.Item2.FieldId == f.Id)); fields = fields.Concat(fieldsToAdd.Select(extQpField => new { FieldName = extQpField.Name, FieldSchema = GetPlainFieldSchema(extQpField) })); } return fields; }) .GroupBy(x => x.FieldName); foreach (var fieldGroup in fieldGroups) { JSchema[] groupSchemas = fieldGroup.Select(pair => pair.FieldSchema).ToArray(); JSchema sameNameExtensionFieldsSchema; if (groupSchemas.Length > 1) { sameNameExtensionFieldsSchema = new JSchema { Type = JSchemaType.Object }; foreach (JSchema extFieldSchema in groupSchemas) { sameNameExtensionFieldsSchema.OneOf.Add(extFieldSchema); } } else { sameNameExtensionFieldsSchema = groupSchemas[0]; } contentSchema.Properties[fieldGroup.Key] = sameNameExtensionFieldsSchema; } }
private ArticleField DeserializePlainField(Quantumart.QP8.BLL.Field plainFieldFromQP, IProductDataSource productDataSource, DBConnector connector) { var field = new PlainArticleField { PlainFieldType = (PlainFieldType)plainFieldFromQP.ExactType }; switch (field.PlainFieldType) { case PlainFieldType.Date: case PlainFieldType.DateTime: DateTime?dt = productDataSource.GetDateTime(plainFieldFromQP.Name); if (dt.HasValue) { field.Value = dt.ToString(); field.NativeValue = dt; } break; case PlainFieldType.Numeric: case PlainFieldType.O2MRelation: { object number; if (plainFieldFromQP.IsInteger || plainFieldFromQP.RelationType == RelationType.OneToMany) { number = productDataSource.GetInt(plainFieldFromQP.Name); } else { var dec = productDataSource.GetDecimal(plainFieldFromQP.Name); number = !plainFieldFromQP.IsDecimal && dec.HasValue ? (object)Convert.ToDouble(dec) : dec; } if (number != null) { field.Value = number.ToString(); field.NativeValue = number; } } break; case PlainFieldType.Image: string imageUrl = productDataSource.GetString(plainFieldFromQP.Name); if (imageUrl != null) { string imageName = Common.GetFileNameByUrl(connector, plainFieldFromQP.Id, imageUrl); field.NativeValue = field.Value = imageName; } break; case PlainFieldType.File: if (productDataSource is EditorJsonProductDataSource) { string fileName = productDataSource.GetString(plainFieldFromQP.Name); field.NativeValue = field.Value = fileName; } else { IProductDataSource fileContainer = productDataSource.GetContainer(plainFieldFromQP.Name); if (fileContainer != null) { string fileUrl = fileContainer.GetString("AbsoluteUrl"); string fileName = Common.GetFileNameByUrl(connector, plainFieldFromQP.Id, fileUrl); field.NativeValue = field.Value = fileName; } } break; case PlainFieldType.Boolean: { decimal?number = productDataSource.GetDecimal(plainFieldFromQP.Name); if (number != null) { field.Value = number.ToString(); field.NativeValue = number; } } break; default: field.NativeValue = field.Value = productDataSource.GetString(plainFieldFromQP.Name); break; } field.Value = field.Value ?? string.Empty; return(field); }