internal CremaDataTableCollection(InternalDataSet dataSet)
{
this.dataSet = dataSet;
this.tables = dataSet.Tables;
this.tables.CollectionChanged += Tables_CollectionChanged;
this.dataSet.PropertyChanged += InternalDataSet_PropertyChanged;
}
protected override void OnRowChanging(DataRowChangeEventArgs e)
{
if (this.RowEventStack.Any() == true)
{
if (this.RowEventStack.Peek() == e.Row)
{
base.OnRowChanging(new InternalDataRowChangeEventArgs(e));
}
else
{
base.OnRowChanging(e);
}
}
else
{
var row = e.Row as InternalTemplateColumn;
switch (e.Action)
{
case DataRowAction.Add:
{
if (this.IsLoading == false)
{
CremaDataSet.ValidateName(row.ColumnName);
}
if (this.targetTable != null && this.IsDiffMode == false)
{
InternalDataSet.ValidateSetDataTypeName(this.targetTable.DataSet, row.DataTypeName);
}
}
break;
}
base.OnRowChanging(e);
}
}
protected override void OnRowChanging(DataRowChangeEventArgs e)
{
if (this.RowEventStack.Any() == true)
{
if (this.RowEventStack.Peek() == e.Row)
{
base.OnRowChanging(new InternalDataRowChangeEventArgs(e));
}
else
{
base.OnRowChanging(e);
}
}
else
{
var row = e.Row as InternalTemplateColumn;
switch (e.Action)
{
case DataRowAction.Add:
{
if (this.IsLoading == false)
{
CremaDataSet.ValidateName(row.ColumnName);
}
if (this.targetTable != null && this.IsDiffMode == false)
{
InternalDataSet.ValidateSetDataTypeName(this.targetTable.DataSet, row.DataTypeName);
}
if (e.Row is InternalTemplateColumn c && c.TargetColumn == null && this.targetTable != null)
{
var dataColumn = new InternalDataColumn()
{
ColumnName = c.ColumnName,
IsKey = c.IsKey,
Unique = c.Unique,
Comment = c.Comment,
DefaultValue = c.DefaultValue ?? (object)DBNull.Value,
AutoIncrement = c.AutoIncrement,
AllowDBNull = c.AllowNull,
Tags = c.Tags,
ReadOnly = c.ReadOnly,
};
this.TargetTable.ValidateAddColumn(dataColumn);
}
}
break;
}
base.OnRowChanging(e);
}
}
public static InternalDataType GetType(InternalDataSet dataSet, string typeName)
{
foreach (var item in dataSet.Tables)
{
if (item is InternalDataType dataType)
{
if (dataType.LocalName == typeName)
{
return(dataType);
}
}
}
return(null);
}
protected virtual void OnValidateSetDataTypeName(string value)
{
var dataSet = this.Table?.DataSet;
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (value is string == false)
{
throw new ArgumentException(nameof(value));
}
if (dataSet == null && CremaDataTypeUtility.IsBaseType(value) == false)
{
if (NameValidator.VerifyItemPath(value) == false)
{
throw new ArgumentException(string.Format(Resources.Exception_TypeCannotBeUsed_Format, value), nameof(value));
}
}
if (CremaDataTypeUtility.IsBaseType(value) == true)
{
this.OnValidateSetDataType(CremaDataTypeUtility.GetType(value));
}
if (dataSet != null && CremaDataTypeUtility.IsBaseType(value) == false)
{
if (NameValidator.VerifyItemPath(value) == false)
{
if (InternalDataSet.ContainsType(this.Table?.DataSet, value) == false)
{
throw new ArgumentException(string.Format(Resources.Exception_TypeCannotBeUsed_Format, value), nameof(value));
}
var dataType = InternalDataSet.GetType(this.Table?.DataSet, value);
this.OnValidateSetCremaType(dataType);
}
else
{
var itemName = new ItemName(value);
if (InternalDataSet.ContainsType(this.Table?.DataSet, itemName.Name, itemName.CategoryPath) == false)
{
throw new ArgumentException(string.Format(Resources.Exception_TypeCannotBeUsed_Format, value), nameof(value));
}
var dataType = InternalDataSet.GetType(this.Table?.DataSet, itemName.Name, itemName.CategoryPath);
this.OnValidateSetCremaType(dataType);
}
}
}
public static InternalDataType GetType(InternalDataSet dataSet, string name, string categoryPath)
{
var itemNamespace = UriUtility.Combine(dataSet.TypeNamespace + categoryPath, name);
foreach (var item in dataSet.Tables)
{
if (item is InternalDataType dataType)
{
if (dataType.Name == name && dataType.Namespace == itemNamespace)
{
return(dataType);
}
}
}
return(null);
}
public static bool ContainsType(InternalDataSet dataSet, string typeName)
{
if (dataSet == null)
{
return(false);
}
foreach (var item in dataSet.Tables)
{
if (item is InternalDataType dataType)
{
if (dataType.LocalName == typeName)
{
return(true);
}
}
}
return(false);
}
public static bool ContainsType(InternalDataSet dataSet, string name, string categoryPath)
{
if (dataSet == null)
{
return(false);
}
var itemNamespace = UriUtility.Combine(dataSet.TypeNamespace + categoryPath, name);
foreach (var item in dataSet.Tables)
{
if (item is InternalDataType dataType)
{
if (dataType.Name == name && dataType.Namespace == itemNamespace)
{
return(true);
}
}
}
return(false);
}
public static void ValidateSetDataTypeName(InternalDataSet dataSet, string value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (value is string == false)
{
throw new ArgumentException(nameof(value));
}
if (dataSet == null && CremaDataTypeUtility.IsBaseType(value) == false)
{
if (NameValidator.VerifyItemPath(value) == false)
{
throw new ArgumentException(string.Format(Resources.Exception_TypeCannotBeUsed_Format, value), nameof(value));
}
}
if (dataSet != null && CremaDataTypeUtility.IsBaseType(value) == false)
{
if (NameValidator.VerifyItemPath(value) == false)
{
if (InternalDataSet.ContainsType(dataSet, value) == false)
{
throw new ArgumentException(string.Format(Resources.Exception_TypeCannotBeUsed_Format, value), nameof(value));
}
}
else
{
var itemName = new ItemName(value);
if (InternalDataSet.ContainsType(dataSet, itemName.Name, itemName.CategoryPath) == false)
{
throw new ArgumentException(string.Format(Resources.Exception_TypeCannotBeUsed_Format, value), nameof(value));
}
}
}
}
internal static string GetTypeName(string baseNamespace, string typeNamespace)
{
return(InternalDataSet.GetTypeName(baseNamespace, typeNamespace));
}
internal static string GetTypeName(CremaDataSet dataSet, string typeNamespace)
{
return(InternalDataSet.GetTypeName((InternalDataSet)dataSet, typeNamespace));
}
internal static string GetTableCategoryPath(string baseNamespace, string tableNamespace)
{
return(InternalDataSet.GetTableCategoryPath(baseNamespace, tableNamespace));
}
internal static string GetTableCategoryPath(CremaDataSet dataSet, string tableNamespace)
{
return(InternalDataSet.GetTableCategoryPath((InternalDataSet)dataSet, tableNamespace));
}
public static string GetTypeName(InternalDataSet dataSet, string typeNamespace)
{
var baseNamespace = dataSet != null ? dataSet.TypeNamespace : CremaSchema.TypeNamespace;
return(GetTypeName(baseNamespace, typeNamespace));
}
private CremaDataTable CopyToCore(CremaDataSet dataSet, bool copyData)
{
this.ValidateCopyTo(dataSet);
var columns = EnumerableUtility.Friends(this, this.Childs).SelectMany(item => item.columns);
foreach (var item in columns)
{
var dataType = item.CremaType;
if (dataType == null)
{
continue;
}
if (dataSet.Types.Contains(dataType.TypeName, dataType.CategoryPath) == false)
{
dataType.CopyTo(dataSet);
}
}
var schemaWriter = GetSchemaWriter();
var action = new Func <string>(() =>
{
using (var sw = new Utf8StringWriter())
{
schemaWriter.Write(sw);
return(sw.ToString());
}
});
var schema = action();
var xml = copyData == true?this.GetXml() : null;
var itemName = new ItemName(this.CategoryPath, this.Name);
dataSet.ReadXmlSchemaString(schema, itemName);
if (xml != null)
{
dataSet.ReadXmlString(xml, itemName);
}
var targetTable = dataSet.Tables[this.Name, this.CategoryPath];
if (this.TemplateNamespace != string.Empty)
{
targetTable.AttachTemplatedParent(this.TemplateNamespace);
}
return(targetTable);
CremaSchemaWriter GetSchemaWriter()
{
if (this.TemplatedParent != null)
{
return(new CremaSchemaWriter(this.TemplatedParent));
}
if (this.TemplateNamespace == string.Empty)
{
return(new CremaSchemaWriter(this));
}
var t1 = InternalDataSet.GetTableName((InternalDataSet)this.DataSet, this.TemplateNamespace);
var c1 = InternalDataSet.GetTableCategoryPath((InternalDataSet)this.DataSet, this.TemplateNamespace);
return(new CremaSchemaWriter(this, new ItemName(c1, t1)));
}
}
public static string GenerateHashValue(params TableInfo[] tables)
{
return(InternalDataSet.GenerateHashValue(tables));
}
public CremaDataSet()
{
this.dataSet = new InternalDataSet(this, CremaDataSet.DefaultDataSetName);
this.tables = new CremaDataTableCollection(this.dataSet);
this.types = new CremaDataTypeCollection(this.dataSet);
}
public static string GetTableCategoryPath(InternalDataSet dataSet, string tableNamespace)
{
var baseNamespace = dataSet != null ? dataSet.TableNamespace : CremaSchema.TableNamespace;
return(GetTableCategoryPath(baseNamespace, tableNamespace));
}
