private void WriteElement(XmlSchema schema, XmlSchemaSequence sequence, CremaDataColumn dataColumn)
{
var element = new XmlSchemaElement()
{
Name = dataColumn.ColumnName,
SchemaTypeName = this.GetXmlQualifiedName(schema, dataColumn)
};
var defaultValue = CremaXmlConvert.ToString(dataColumn.DefaultValue, dataColumn.DataType);
if (string.IsNullOrEmpty(defaultValue) == false)
{
element.DefaultValue = defaultValue;
}
if (dataColumn.AllowDBNull == true && dataColumn.IsKey == false)
{
element.MinOccursString = "0";
}
element.WriteAppInfo(CremaSchema.ColumnInfo, CremaSchema.Creator, dataColumn.CreationInfo.ID, schema.TargetNamespace);
element.WriteAppInfo(CremaSchema.ColumnInfo, CremaSchema.CreatedDateTime, dataColumn.CreationInfo.DateTime, schema.TargetNamespace);
element.WriteAppInfo(CremaSchema.ColumnInfo, CremaSchema.Modifier, dataColumn.ModificationInfo.ID, schema.TargetNamespace);
element.WriteAppInfo(CremaSchema.ColumnInfo, CremaSchema.ModifiedDateTime, dataColumn.ModificationInfo.DateTime, schema.TargetNamespace);
element.WriteAppInfo(CremaSchema.ColumnInfo, CremaSchema.AutoIncrement, dataColumn.AutoIncrement, schema.TargetNamespace);
element.WriteAppInfo(CremaSchema.ColumnInfo, CremaSchema.ID, dataColumn.ColumnID, schema.TargetNamespace);
element.WriteAppInfo(CremaSchema.ColumnInfo, CremaSchema.Tags, dataColumn.Tags, schema.TargetNamespace);
element.WriteAppInfo(CremaSchema.ColumnInfo, CremaSchema.ReadOnly, dataColumn.ReadOnly, schema.TargetNamespace);
element.WriteDescription(dataColumn.Comment);
sequence.Items.Add(element);
}
private void WriteAttribute(XmlSchema schema, XmlSchemaComplexType complexType, CremaAttribute attribute)
{
var schemaAttribute = new XmlSchemaAttribute()
{
Name = attribute.AttributeName,
SchemaTypeName = GetSystemQualifiedName(attribute.DataType, schema.TargetNamespace)
};
if (attribute.AllowDBNull == false)
{
if (attribute.DefaultValue == DBNull.Value)
{
schemaAttribute.Use = XmlSchemaUse.Required;
}
else
{
schemaAttribute.Use = XmlSchemaUse.Optional;
}
}
var defaultValue = attribute.DefaultValue;
if (defaultValue != DBNull.Value)
{
schemaAttribute.DefaultValue = CremaXmlConvert.ToString(defaultValue, attribute.DataType);
}
schemaAttribute.WriteAppInfo(CremaSchema.AttributeInfo, CremaSchema.AutoIncrement, attribute.AutoIncrement, schema.TargetNamespace);
schemaAttribute.WriteAppInfo(CremaSchema.AttributeInfo, CremaSchema.Comment, attribute.Comment, schema.TargetNamespace);
complexType.Attributes.Add(schemaAttribute);
}
internal static void WriteFields(XmlWriter writer, string propertyName, object[] fields)
{
writer.WriteStartElement(propertyName);
if (fields != null)
{
foreach (var item in fields)
{
writer.WriteStartElement("item");
if (item is DBNull)
{
writer.WriteAttributeString("type", nameof(DBNull));
}
else if (item != null)
{
if (item is Guid)
{
writer.WriteAttributeString("type", nameof(Guid));
}
else
{
writer.WriteAttributeString("type", item.GetType().GetTypeName());
}
writer.WriteString(CremaXmlConvert.ToString(item));
}
writer.WriteEndElement();
}
}
writer.WriteEndElement();
}
public DomainFieldInfo(object field)
{
if (field is DBNull)
{
this.Type = nameof(DBNull);
this.Value = null;
}
else if (field != null)
{
if (field is Guid)
{
this.Type = nameof(Guid);
}
else
{
this.Type = field.GetType().GetTypeName();
}
this.Value = CremaXmlConvert.ToString(field);
}
else
{
this.Type = null;
this.Value = null;
}
}
private void ReadColumn(XmlSchemaElement element, CremaDataTable dataTable)
{
var dataColumn = new CremaDataColumn()
{
InternalColumnName = element.Name,
InternalComment = element.ReadDescription(),
};
this.ReadColumnDataType(element.ElementSchemaType as XmlSchemaSimpleType, dataColumn);
if (element.MinOccursString == null)
{
dataColumn.InternalAllowDBNull = false;
}
if (string.IsNullOrEmpty(element.DefaultValue) == false)
{
dataColumn.InternalDefaultValue = CremaXmlConvert.ToValue(element.DefaultValue, dataColumn.DataType);
}
if (this.version.Major == CremaSchema.MajorVersion)
{
this.ReadColumnInfo(element, dataColumn);
}
else
{
this.ReadColumnInfoVersion2(element, dataColumn);
}
dataTable.Columns.Add(dataColumn);
}
private void ReadAttribute(XmlSchemaAttribute schemaAttribute, CremaDataTable dataTable)
{
if (schemaAttribute.Name == CremaSchema.RelationID)
{
return;
}
var attributeName = schemaAttribute.Name == CremaSchemaObsolete.DataLocation ? CremaSchema.Tags : schemaAttribute.Name;
var attribute = dataTable.Attributes[attributeName];
if (attribute == null)
{
attribute = dataTable.Attributes.Add(attributeName);
}
if (schemaAttribute.Use == XmlSchemaUse.Required)
{
attribute.AllowDBNull = false;
}
if (string.IsNullOrEmpty(schemaAttribute.DefaultValue) == false)
{
attribute.DefaultValue = CremaXmlConvert.ToValue(schemaAttribute.DefaultValue, attribute.DataType);
}
attribute.AutoIncrement = schemaAttribute.ReadAppInfoAsBoolean(CremaSchema.AttributeInfo, CremaSchema.AutoIncrement);
attribute.Comment = schemaAttribute.ReadAppInfoAsString(CremaSchema.AttributeInfo, CremaSchema.Comment);
}
internal static Guid ReadAppInfoAsGuid(this XmlSchemaAnnotated annotated, string nodeName, string attributeName, Guid defaultValue)
{
var text = ReadAppInfoAsString(annotated, nodeName, attributeName);
if (text == null)
{
return(defaultValue);
}
return(CremaXmlConvert.ToGuid(text));
}
internal static DateTime ReadAppInfoAsDateTime(this XmlSchemaAnnotated annotated, string nodeName, string attributeName, XmlDateTimeSerializationMode mode, DateTime defaultValue)
{
var text = ReadAppInfoAsString(annotated, nodeName, attributeName);
if (text == null)
{
return(defaultValue);
}
return(CremaXmlConvert.ToDateTime(text, mode));
}
protected override void OnReadXml(XmlReader reader)
{
var value1 = reader.ReadElementContentAsString();
this.value = (T)CremaXmlConvert.ToValue(value1, typeof(T));
reader.MoveToContent();
var value2 = reader.ReadElementContentAsString();
this.operatorType = (OperatorType)Enum.Parse(typeof(OperatorType), value2);
}
public object ToValue()
{
if (this.Value != null)
{
var type = this.Type == nameof(Guid) ? typeof(Guid) : CremaDataTypeUtility.GetType(this.Type);
return(CremaXmlConvert.ToValue(this.Value, type));
}
else if (this.Type == nameof(DBNull))
{
return(DBNull.Value);
}
else
{
return(null);
}
}
internal static object[] ReadFields(XmlReader reader, string propertyName)
{
reader.MoveToContent();
if (reader.IsEmptyElement == false)
{
var fieldList = new List <object>();
reader.ReadStartElement(propertyName);
while (reader.MoveToContent() == XmlNodeType.Element)
{
var attr = reader.GetAttribute("type");
if (reader.IsEmptyElement == false)
{
var text = reader.ReadElementContentAsString();
var type = attr == nameof(Guid) ? typeof(Guid) : CremaDataTypeUtility.GetType(attr);
var field = CremaXmlConvert.ToValue(text, type);
fieldList.Add(field);
}
else if (attr == nameof(DBNull))
{
fieldList.Add(DBNull.Value);
reader.Skip();
}
else
{
fieldList.Add(null);
reader.Skip();
}
}
reader.ReadEndElement();
return(fieldList.ToArray());
}
else
{
reader.Skip();
return(null);
}
}
internal static void WriteAppInfo(this XmlSchemaAnnotated annotated, string nodeName, string attributeName, Guid value, string ns, Guid defaultValue)
{
WriteAppInfo(annotated, nodeName, attributeName, CremaXmlConvert.ToString(value), ns, CremaXmlConvert.ToString(defaultValue));
}
