public void Test10()
{
var dataSet = new CremaDataSet();
var dataType = dataSet.Types.Add();
dataType.AddMember("None", 0);
dataType.AddMember("A", 0);
var dataTable = dataSet.Tables.Add();
dataTable.Columns.AddKey("column1");
var dataRow = dataTable.NewRow();
dataRow[0] = "None";
dataTable.Rows.Add(dataRow);
var dataRow2 = dataTable.NewRow();
dataRow2[0] = "B";
dataTable.Rows.Add(dataRow2);
dataSet.AcceptChanges();
var template = new CremaTemplate(dataTable);
template.Columns[0].DataTypeName = dataType.Path;
}
public Table AddNew(Authentication authentication, CremaTemplate template)
{
try
{
this.DataBase.ValidateBeginInDataBase(authentication);
var dataSet = template.TargetTable.DataSet.Copy();
this.Container.InvokeChildTableCreate(authentication, this, dataSet);
var tableName = template.TableName;
var childTable = this.Container.AddNew(authentication, CremaDataTable.GenerateName(base.Name, tableName), template.CategoryPath);
childTable.Initialize(dataSet.Tables[childTable.Name, childTable.Category.Path].TableInfo);
foreach (var item in this.DerivedTables)
{
var derivedChild = this.Container.AddNew(authentication, CremaDataTable.GenerateName(item.Name, tableName), item.Category.Path);
derivedChild.TemplatedParent = childTable;
derivedChild.Initialize(dataSet.Tables[derivedChild.Name, derivedChild.Category.Path].TableInfo);
}
this.Sign(authentication);
var items = EnumerableUtility.Friends(childTable, childTable.DerivedTables).ToArray();
this.Container.InvokeTablesCreatedEvent(authentication, items, dataSet);
return(childTable);
}
catch (Exception e)
{
this.CremaHost.Error(e);
throw;
}
}
public CremaTemplateColumn_InTemplate_PropertyTest()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
this.template = new CremaTemplate(dataSet.Tables.Random(item => item.TemplateNamespace == string.Empty));
this.column = this.template.Columns.Random();
}
protected override async Task <CremaTemplate> CreateSourceAsync(Authentication authentication)
{
if (this.parent is TableCategory category)
{
var typeContext = category.GetService(typeof(TypeContext)) as TypeContext;
var tableContext = category.GetService(typeof(TableContext)) as TableContext;
var dataSet = await category.ReadDataForNewTemplateAsync(authentication);
var tableNames = await tableContext.Dispatcher.InvokeAsync(() => tableContext.Tables.Select((Table item) => item.Name).ToArray());
var newName = NameUtility.GenerateNewName(nameof(Table), tableNames);
var templateSource = CremaTemplate.Create(dataSet, newName, category.Path);
return(templateSource);
}
else if (this.parent is Table table)
{
var dataSet = await table.ReadDataForNewTemplateAsync(authentication);
var dataTable = dataSet.Tables[table.Name, table.Category.Path];
var childNames = await table.Dispatcher.InvokeAsync(() => table.Childs.Select(item => item.TableName).Concat(new string[] { table.TableName }).ToArray());
var newName = NameUtility.GenerateNewName(ChildString, childNames);
var template = CremaTemplate.Create(dataTable);
template.TableName = newName;
return(template);
}
throw new NotImplementedException();
}
private void Draw(CremaTemplate template)
{
throw new NotImplementedException("dotnet");
// var columns = GetColumns();
// var tableDataBuilder = new TableDataBuilder(columns);
// var count = 0;
// foreach (var item in template.Columns)
// {
// var fieldList = new List<string>
// {
// item.Name,
// item.IsKey ? "O" : string.Empty,
// item.DataTypeName,
// item.Comment
// };
// tableDataBuilder.Add(fieldList.ToArray());
// count++;
// }
// this.Out.WriteLine();
// this.Out.PrintTableData(tableDataBuilder.Data, true);
// this.Out.WriteLine();
#pragma warning disable CS8321 // 로컬 함수 'GetColumns'이(가) 선언되었지만 사용되지 않았습니다.
string[] GetColumns()
#pragma warning restore CS8321 // 로컬 함수 'GetColumns'이(가) 선언되었지만 사용되지 않았습니다.
{
var query = from item in this.GetColumnProperties(false)
//where item == nameof(CremaTemplateColumn.Name) || StringUtility.GlobMany(item, PreviewProperties.Columns)
select item;
return(query.ToArray());
}
}
public static Task <ViewTemplateViewModel> CreateInstanceAsync(Authentication authentication, ITableDescriptor descriptor)
{
if (authentication == null)
{
throw new ArgumentNullException(nameof(authentication));
}
if (descriptor == null)
{
throw new ArgumentNullException(nameof(descriptor));
}
if (descriptor.Target is ITable table)
{
return(table.Dispatcher.InvokeAsync(() =>
{
var dataSet = table.GetDataSet(authentication, -1);
var dataTable = dataSet.Tables[table.Name];
var template = new CremaTemplate(dataTable);
return new ViewTemplateViewModel(authentication, template);
}));
}
else
{
throw new ArgumentException("Invalid Target of Descriptor", nameof(descriptor));
}
}
protected TemplateViewModel(CremaTemplate template, bool isNew)
{
this.DisplayName = Resources.Title_EditTableTemplate;
this.isNew = isNew;
this.template = template;
this.Initialize();
}
internal DiffTemplate(CremaDataTable diffTable1, CremaDataTable diffTable2, CremaDataTable dataTable1, CremaDataTable dataTable2)
{
this.diffTable1 = diffTable1.CloneTo(new CremaDataSet());
this.diffTable2 = diffTable2.CloneTo(new CremaDataSet());
foreach (var item in diffTable1.Columns)
{
var column = this.diffTable1.Columns[item.ColumnName];
DiffUtility.SetDiffState(column, DiffUtility.GetDiffState(item));
}
foreach (var item in diffTable2.Columns)
{
var column = this.diffTable2.Columns[item.ColumnName];
DiffUtility.SetDiffState(column, DiffUtility.GetDiffState(item));
}
this.dataTable1 = dataTable1;
this.dataTable2 = dataTable2;
this.diffSource1 = Create(this.diffTable1);
this.diffSource2 = Create(this.diffTable2);
this.diffSource1.ExtendedProperties[typeof(DiffTemplate)] = this;
this.diffSource2.ExtendedProperties[typeof(DiffTemplate)] = this;
this.dummy1 = this.diffSource1.TableName.StartsWith(DiffUtility.DiffDummyKey);
this.dummy2 = this.diffSource2.TableName.StartsWith(DiffUtility.DiffDummyKey);
this.AttachEventHandler(this.diffSource1, diffTable1);
this.AttachEventHandler(this.diffSource2, diffTable2);
}
protected override CremaTemplate CreateSource(Authentication authentication)
{
var dataSet = this.parent.ReadAll(authentication);
var dataTable = dataSet.Tables[this.parent.TableName, this.parent.Category.Path];
return(CremaTemplate.CreateChild(dataTable));
}
public void Test11()
{
var dataSet = new CremaDataSet();
var dataType = dataSet.Types.Add();
dataType.AddMember("None", 0);
dataType.AddMember("A", 1);
var dataTable = dataSet.Tables.Add();
dataTable.Columns.AddKey("column1");
var dataRow = dataTable.NewRow();
dataRow[0] = "None";
dataTable.Rows.Add(dataRow);
var dataRow2 = dataTable.NewRow();
dataRow2[0] = "A";
dataTable.Rows.Add(dataRow2);
var dataTable2 = dataTable.Inherit("Derived1");
dataSet.AcceptChanges();
//dataTable.Columns[0].CremaType = dataType;
var template = new CremaTemplate(dataTable);
template.Columns[0].DataTypeName = dataType.Path;
Assert.AreEqual(dataType, dataTable.Columns[0].CremaType);
Assert.AreEqual(dataType, dataTable2.Columns[0].CremaType);
}
public void Add()
{
var table = this.dataSet.Tables.First();
var template = new CremaTemplate(table);
var member = template.NewColumn();
template.Columns.Add(member);
}
private void Detach()
{
if (this.template != null)
{
this.template.PropertyChanged -= Template_PropertyChanged;
}
this.template = null;
}
protected override CremaTemplate CreateSource(Authentication authentication)
{
var typeContext = this.category.GetService(typeof(TypeContext)) as TypeContext;
var dataSet = typeContext.Root.ReadData(authentication, true);
var newName = NameUtility.GenerateNewName("Table", this.category.Context.Tables.Select((Table item) => item.Name));
var templateSource = CremaTemplate.Create(dataSet, newName, this.category.Path);
return(templateSource);
}
protected override void OnInitialize(DomainMetaData metaData)
{
base.OnInitialize(metaData);
var xml = Encoding.UTF8.GetString(metaData.Data).Decompress();
this.template = XmlSerializerUtility.ReadString <CremaTemplate>(xml);
this.view = this.template.View;
}
protected override void OnInitialize(byte[] data)
{
base.OnInitialize(data);
var xml = Encoding.UTF8.GetString(data).Decompress();
this.TemplateSource = XmlSerializerUtility.ReadString <CremaTemplate>(xml);
this.view = this.TemplateSource.View;
}
public ViewTemplateViewModel(Authentication authentication, CremaTemplate template)
{
this.DisplayName = Resources.Title_ViewTableTemplate;
this.authentication = authentication;
this.template = template;
this.tableName = this.template.TableName;
this.comment = this.template.Comment;
this.tags = this.template.Tags;
}
public static void DeleteItems(this CremaTemplate template)
{
foreach (var item in template.Items.ToArray())
{
if ((bool)item.GetAttribute(DiffUtility.DiffEnabledKey) == false)
{
item.Delete();
}
}
}
public void Test3_Fail()
{
var dataTable = new CremaDataTable();
var c1 = dataTable.Columns.Add("Column1", typeof(float));
var template = new CremaTemplate(dataTable);
template.Columns[0].DefaultValue = "10000000.0";
template.Columns[0].DataTypeName = typeof(DateTime).GetTypeName();
}
public void Test5_Fail2()
{
var dataTable = new CremaDataTable();
var c1 = dataTable.Columns.Add("Column1", typeof(string));
var template = new CremaTemplate(dataTable);
template.Columns[0].DefaultValue = "1";
template.Columns[0].SetDataType(typeof(TimeSpan));
template.Columns[0].DefaultValue = "62.24:00:00";
}
public void Test7()
{
var dataSet = new CremaDataSet();
var dataType = dataSet.AddRandomType();
var dataTable = dataSet.AddRandomTable();
var template = new CremaTemplate(dataTable);
var column = template.NewColumn();
column.DataTypeName = "/type1";
}
public void Test6()
{
var dataTable = new CremaDataTable();
var c1 = dataTable.Columns.Add("Column1", typeof(string));
var template = new CremaTemplate(dataTable);
template.Columns[0].DefaultValue = "1";
template.Columns[0].SetDataType(typeof(TimeSpan));
template.Columns[0].DefaultValue = TimeSpan.MinValue.ToString();
template.Columns[0].DefaultValue = TimeSpan.MaxValue.ToString();
}
public TableTemplateDomain(DomainSerializationInfo serializationInfo, object source)
: base(serializationInfo, source)
{
this.IsNew = (bool)serializationInfo.GetProperty(nameof(IsNew));
this.template = source as CremaTemplate;
this.view = this.template.View;
var dataSet = this.template.DataTable.DataSet;
var itemPaths = (string)serializationInfo.GetProperty(nameof(ItemPaths));
dataSet.SetItemPaths(StringUtility.Split(itemPaths, ';'));
}
public void AddEmpty()
{
var table = this.dataSet.Tables.First();
var template = new CremaTemplate(table);
var memberCount = template.Columns.Count;
var member = template.NewColumn();
template.Columns.Add(member);
Assert.AreNotEqual(member.Name, string.Empty);
Assert.AreEqual(member.Index + 1, template.Columns.Count);
Assert.AreEqual(memberCount + 1, template.Columns.Count);
}
private void Attach()
{
if (this.viewModel != null)
{
this.template = this.GetTemplate(this.viewModel);
this.template.PropertyChanged += Template_PropertyChanged;
this.DisplayName = this.GetHeader(this.viewModel);
this.TableInfo = this.template.TableInfo;
}
this.NotifyOfPropertyChange(nameof(this.IsVisible));
this.NotifyOfPropertyChange(nameof(this.SelectedObject));
}
public void SetIndex()
{
var table = this.dataSet.Tables.First();
var template = new CremaTemplate(table);
for (int i = 0; i < 100; i++)
{
var member = RandomUtility.Random(template.Columns);
var index = RandomUtility.Next(template.Columns.Count);
member.Index = index;
Assert.AreEqual(member, template.Columns[index]);
}
}
public static CremaTemplateColumn AddEmptyColumn(this CremaTemplate template)
{
template.BeginLoadData();
var column = template.NewColumn();
column.TargetColumn = template.TargetTable.Columns.Add();
column.EmptyFields();
column.SetAttribute(DiffUtility.DiffEnabledKey, false);
column.SetAttribute(DiffUtility.DiffStateKey, DiffState.Imaginary);
template.Columns.Add(column);
template.EndLoadData();
return(column);
}
protected override void OnEndEdit(Authentication authentication, CremaTemplate template)
{
this.Container.InvokeTableEndTemplateEdit(authentication, this.table, this.TemplateSource);
base.OnEndEdit(authentication, template);
this.table.UpdateTemplate(template.TableInfo);
this.table.UpdateTags(template.Tags);
this.table.UpdateComment(template.Comment);
this.table.SetTableState(TableState.None);
var items = EnumerableUtility.One(this.table).ToArray();
this.Container.InvokeTablesStateChangedEvent(authentication, items);
this.Container.InvokeTablesTemplateChangedEvent(authentication, items, this.TemplateSource.TargetTable.DataSet);
}
public DiffTemplate(CremaDataTable table1, CremaDataTable table2, DiffMergeTypes mergeType)
{
this.diffTable1 = table1;
this.diffTable2 = table2;
this.diffSource1 = new CremaTemplate()
{
TargetTable = table1
};
this.diffSource2 = new CremaTemplate()
{
TargetTable = table2
};
this.mergeType = mergeType;
}
public void Test12()
{
var dataSet1 = new CremaDataSet();
var template = CremaTemplate.Create(dataSet1, "table1", "/");
var column1 = template.AddColumn("Column1");
var column2 = template.AddColumn("Column2");
var column3 = template.AddColumn("Column3");
column3.Index = 0;
Assert.AreEqual(0, column3.Index);
Assert.AreEqual(1, column1.Index);
Assert.AreEqual(2, column2.Index);
}
public Table AddNew(Authentication authentication, CremaTemplate template)
{
var dataSet = template.TargetTable.DataSet.Copy();
var dataTable = dataSet.Tables[template.TableName, template.CategoryPath];
var categoryPath = dataTable.CategoryPath;
this.ValidateAddNew(dataTable.TableName, categoryPath, authentication);
this.Sign(authentication);
this.InvokeTableCreate(authentication, dataTable.TableName, categoryPath, dataTable, null);
var table = this.AddNew(authentication, dataTable.TableName, categoryPath);
table.Initialize(dataTable.TableInfo);
this.InvokeTablesCreatedEvent(authentication, new Table[] { table }, dataSet);
return(table);
}
