public void InvokeTableDelete(Authentication authentication, Table table, CremaDataSet dataSet)
{
this.CremaHost.DebugMethod(authentication, this, nameof(InvokeTableDelete), table);
try
{
if (dataSet != null)
{
var dataTables = dataSet != null ? new DataTableCollection(dataSet, this.DataBase) : null;
var dataTable = dataSet.Tables[table.Name, table.Category.Path];
var parentTable = dataTable.Parent;
if (parentTable != null)
{
parentTable.Childs.Remove(dataTable);
}
else
{
dataSet.Tables.Remove(dataTable);
}
dataTables.Modify(this.Repository);
}
else
{
if (table.TemplatedParent == null)
{
this.Repository.Delete(table.SchemaPath);
}
this.Repository.Delete(table.XmlPath);
}
this.Context.InvokeTableItemDelete(authentication, table);
}
catch
{
this.Repository.Revert();
throw;
}
}
public async Task NewTypeAsync()
{
var dataSet = new CremaDataSet();
foreach (var item in this.dataSet.Types)
{
item.CopyTo(dataSet);
}
var dataType = dataSet.Types.Add();
var dialog = new NewTypeViewModel(dataType);
if (await dialog.ShowDialogAsync() != true)
{
return;
}
var copiedType = dataType.CopyTo(this.dataSet);
//var dataType = template.TargetType.CopyTo(this.dataSet);
var viewModel = new TypeTreeViewItemViewModel(copiedType, this.selector)
{
Parent = this,
};
}
public void WriteToFile_ReadFromFile()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var testSet = new CremaDataSet();
foreach (var item in dataSet.Types)
{
string schemaPath = PathUtility.GetTempFileName();
item.Write(schemaPath);
try
{
testSet.ReadType(schemaPath);
}
finally
{
FileUtility.Delete(schemaPath);
}
var newType = testSet.Types[item.TypeName];
CremaComparer.CompareType(item, newType);
}
}
public void RemoveType()
{
var dataSet = new CremaDataSet();
var type = dataSet.Types.Add();
type.AddRandomMembers(10);
type.AcceptChanges();
var table = dataSet.Tables.Add();
var column = table.Columns.Add("Column1", type);
foreach (var item in type.Members)
{
var row = table.NewRow();
row[column] = item.Name;
table.Rows.Add(row);
}
table.Inherit("table1_ref", true);
column.CremaType = null;
dataSet.Types.Remove(type);
}
public async Task NewTableAsync()
{
var dataSet = new CremaDataSet();
foreach (var item in this.dataSet.Types)
{
item.CopyTo(dataSet);
}
var tableName = NameUtility.GenerateNewName("Table", this.dataSet.Tables.Select(item => item.Name));
var template = CremaTemplate.Create(dataSet, tableName, this.categoryPath);
var dialog = new NewTableViewModel(this.dataSet, template);
if (await dialog.ShowDialogAsync() != true)
{
return;
}
var dataTable = template.DataTable.CopyTo(this.dataSet);
var viewModel = new TableTreeViewItemViewModel(dataTable, this.selector)
{
Parent = this,
};
}
public static void CreateRandomType(CremaDataSet dataSet, string typeName, string categoryPath)
{
var dataType = dataSet.Types.Add(typeName, categoryPath);
dataType.IsFlag = RandomUtility.NextBoolean();
if (dataType.IsFlag == true)
{
for (var i = 0; i < RandomUtility.Next(1, 128); i++)
{
dataType.AddMember($"{typeName}_member_{RandomUtility.NextIdentifier()}", i, RandomUtility.NextString());
}
}
else
{
dataType.AddMember("none", 0);
for (var i = 0; i < RandomUtility.Next(32); i++)
{
dataType.AddMember($"{typeName}_flag_{RandomUtility.NextIdentifier()}", (long)0x1 << RandomUtility.Next(32), RandomUtility.NextString());
}
dataType.AddMember("all", -1);
}
}
public async Task OpenAsync(string path)
{
try
{
this.BeginProgress();
this.dataSet = await Task.Run(() => this.ReadDataSet(path));
this.dataSet.SignatureDateProvider = new SignatureDateProvider("CremaInternal");
this.EndProgress();
this.OnLoaded(EventArgs.Empty);
}
catch (Exception e)
{
await AppMessageBox.ShowErrorAsync(e.Message);
this.EndProgress();
return;
}
this.Initialize();
this.filename = path;
this.NotifyOfPropertyChange(() => this.Filename);
}
public CremaDataSet GetTableData(string repositoryPath, string tableXmlPath, string tableSchemaPath, long revision)
{
var tempPath = PathUtility.GetTempPath(true);
try
{
var revisionValue = revision == -1 ? this.Revision : revision;
var repoUri = this.GetUri(repositoryPath, revisionValue);
var xmlUri = this.GetUri(tableXmlPath, revisionValue);
var baseUri = this.GetDataBaseUri($"{repoUri}", $"{xmlUri}");
var xmlPath = this.Export(xmlUri, tempPath);
var xmlInfo = new CremaXmlReadInfo(xmlPath);
var schemaUri = UriUtility.Combine(UriUtility.GetDirectoryName(xmlUri), xmlInfo.RelativeSchemaPath + "@" + revisionValue);
var schemaPath = this.Export(schemaUri, tempPath);
var xsdInfo = new CremaSchemaReadInfo(schemaPath);
foreach (var item in xsdInfo.RelativeTypePaths)
{
var typeUri = UriUtility.Combine(UriUtility.GetDirectoryName(schemaUri), $"{item}@{revisionValue}");
this.Export(typeUri, tempPath);
}
var pureBaseUri = $"{baseUri}".Replace($"@{revisionValue}", string.Empty);
var pureTableXmlUri = $"{xmlUri}".Replace($"@{revisionValue}", string.Empty);
var dataBaseRelativeUri = UriUtility.MakeRelativeOfDirectory(pureTableXmlUri, pureBaseUri);
var dataBasePath = UriUtility.Combine(new Uri(xmlPath), dataBaseRelativeUri).LocalPath;
return(CremaDataSet.ReadFromDirectory(dataBasePath));
}
finally
{
DirectoryUtility.Delete(tempPath);
}
}
public void ImportTest1()
{
var dataSet1 = new CremaDataSet();
var dataTable1 = dataSet1.Tables.Add();
var c1 = dataTable1.Columns.Add();
c1.DefaultValue = "1";
//c1.IsKey = true;
var dataRow1 = dataTable1.AddRow();
var dataRow2 = dataTable1.AddRow("2");
var childTable1 = dataTable1.Childs.Add();
childTable1.Columns.Add();
var childRow1 = childTable1.AddRow(dataRow1, "a");
//childTable.Childs.Add("w123qwerweqr");
dataTable1.AcceptChanges();
//dataTable1.DefaultView[0][CremaSchema.Index] = 1;
//dataRow1.Index = 1;
dataTable1.AcceptChanges();
var dataSet2 = new CremaDataSet();
var dataTable2 = dataSet2.Tables.Add();
var c2 = dataTable2.Columns.Add();
//c2.IsKey = true;
var childTable2 = dataTable2.Childs.Add();
dataTable2.ImportRow(dataRow1);
childTable2.ImportRow(childRow1);
}
public void RelationChangedTest()
{
Assert.Inconclusive("관계값을 인덱스로 이 테스트는 잘못된 테스트임");
var dataSet = new CremaDataSet();
var dataTable1 = dataSet.Tables.Add();
var childTable1 = dataTable1.Childs.Add();
var dataTable2 = dataTable1.Inherit();
var childTable2 = dataTable2.Childs[0];
var column1 = dataTable1.Columns.Add();
var column2 = dataTable1.Columns.Add();
column1.IsKey = true;
var dataRow1 = dataTable1.NewRow();
dataRow1[column1] = "a";
dataRow1[column2] = "b";
dataTable1.Rows.Add(dataRow1);
var dataRow2 = dataTable1.NewRow();
dataRow2[column1] = "b";
dataRow2[column2] = "a";
dataTable1.Rows.Add(dataRow2);
var relationID1 = dataRow1.RelationID;
var relationID2 = dataRow2.RelationID;
column1.IsKey = false;
column2.IsKey = true;
Assert.AreEqual(dataRow1.RelationID, relationID2);
Assert.AreEqual(dataRow2.RelationID, relationID1);
}
public static void CompareDataSet(CremaDataSet dataSet1, CremaDataSet dataSet2)
{
if (dataSet1 == null && dataSet2 == null)
{
return;
}
if (dataSet1 == null || dataSet2 == null)
{
Assert.Fail("타입이 같지 않습니다.");
}
CompareSchema(dataSet1, dataSet2);
CompareXml(dataSet1, dataSet2);
Assert.AreEqual(dataSet1.DataSetName, dataSet2.DataSetName, "DataSetName");
Assert.AreEqual(dataSet1.Namespace, dataSet2.Namespace, "Namespace");
Assert.AreEqual(dataSet1.TableNamespace, dataSet2.TableNamespace, "TableNamespace");
Assert.AreEqual(dataSet1.TypeNamespace, dataSet2.TypeNamespace, "TypeNamespace");
Assert.AreEqual(dataSet1.Tables.Count, dataSet2.Tables.Count, "Tables.Count");
for (int i = 0; i < dataSet1.Tables.Count; i++)
{
var table1 = dataSet1.Tables[i];
var table2 = dataSet2.Tables[table1.Name, table1.CategoryPath];
CremaComparer.CompareTable(table1, table2);
}
Assert.AreEqual(dataSet1.Types.Count, dataSet2.Types.Count, "Types.Count");
for (int i = 0; i < dataSet1.Types.Count; i++)
{
var type1 = dataSet1.Types[i];
var type2 = dataSet2.Types[type1.TypeName];
CremaComparer.CompareType(type1, type2);
}
}
public void ComplexTest1()
{
Assert.Inconclusive("관계값을 인덱스로 바꾸면서 오류가 발생하는데 이테스트의 의도가 먼지 기억이 안남");
var dataSet = new CremaDataSet();
var table1 = dataSet.Tables.Add();
var column1 = table1.Columns.AddKey();
var child1 = table1.Childs.Add();
child1.Columns.AddKey();
var row1 = table1.NewRow();
row1[0] = "1";
table1.Rows.Add(row1);
var relationID = row1.RelationID;
var childCount = 4;
for (var i = 0; i < childCount; i++)
{
var childRow1 = child1.NewRow(row1);
childRow1[0] = i.ToString();
child1.Rows.Add(childRow1);
}
dataSet.AcceptChanges();
dataSet.BeginLoad();
table1.DefaultView[0].BeginEdit();
table1.DefaultView[0][7] = "2";
table1.DefaultView[0][8] = "randomid";
table1.DefaultView[0].EndEdit();
dataSet.EndLoad();
var sss = row1.GetChildRows(child1);
Assert.AreEqual(childCount, sss.Length);
}
public CremaDataSet GetTypeData(string repositoryPath, string typeSchemaPath, long revision)
{
string tempPath = PathUtility.GetTempPath(true);
try
{
var revisionValue = revision == -1 ? this.Revision : revision;
var repoUri = this.GetUri(repositoryPath, revisionValue);
var schemaUri = this.GetUri(typeSchemaPath, revisionValue);
var baseUri = this.GetDataBaseUri($"{repoUri}", $"{schemaUri}");
var schemaPath = this.Export(schemaUri, tempPath);
var pureBaseUri = $"{baseUri}".Replace($"@{revisionValue}", string.Empty);
var pureSchemaUri = $"{schemaUri}".Replace($"@{revisionValue}", string.Empty);
var dataBaseRelativeUri = UriUtility.MakeRelativeOfDirectory(pureSchemaUri, pureBaseUri);
var dataBasePath = UriUtility.Combine(new Uri(schemaPath), dataBaseRelativeUri).LocalPath;
return(CremaDataSet.ReadFromDirectory(dataBasePath));
}
finally
{
DirectoryUtility.Delete(tempPath);
}
}
public void Contains()
{
CremaDataSet dataSet = new CremaDataSet();
Assert.IsFalse(dataSet.Types.Contains("Type1"));
Assert.IsFalse(dataSet.Types.Contains("Type1", "/A/"));
Assert.IsFalse(dataSet.Types.Contains("Type1", "/B/"));
var type1 = dataSet.Types.Add("Type1");
Assert.IsTrue(dataSet.Types.Contains("Type1"));
Assert.IsTrue(dataSet.Types.Contains("Type1", "/"));
Assert.IsFalse(dataSet.Types.Contains("Type1", "/A/"));
Assert.IsFalse(dataSet.Types.Contains("Type1", "/B/"));
var type2 = dataSet.Types.Add("Type1", "/A/");
Assert.IsTrue(dataSet.Types.Contains("Type1", "/A/"));
var type3 = dataSet.Types.Add("Type1", "/B/");
Assert.IsTrue(dataSet.Types.Contains("Type1", "/B/"));
}
public void CanRemove()
{
CremaDataSet dataSet = new CremaDataSet();
var type1 = dataSet.Types.Add("Type1");
var type2 = dataSet.Types.Add("Type1", "/A/");
var type3 = dataSet.Types.Add("Type1", "/B/");
var type4 = new CremaDataType();
Assert.IsTrue(dataSet.Types.CanRemove(type1));
Assert.IsTrue(dataSet.Types.CanRemove(type2));
Assert.IsTrue(dataSet.Types.CanRemove(type3));
Assert.IsFalse(dataSet.Types.CanRemove(type4));
dataSet.Types.Remove(type1);
dataSet.Types.Remove(type2);
dataSet.Types.Remove(type3);
Assert.IsFalse(dataSet.Types.CanRemove(type1));
Assert.IsFalse(dataSet.Types.CanRemove(type2));
Assert.IsFalse(dataSet.Types.CanRemove(type3));
}
public async Task InitializeAsync(TestContext context)
{
var basePath = Path.Combine(context.TestRunDirectory, "repo");
var repositoryPath = GenerateRepositoryPath();
var userInfos = UserInfoGenerator.Generate(0, 0);
var dataSet = new CremaDataSet();
await Task.Run(() => CremaBootstrapper.CreateRepositoryInternal(this, repositoryPath, "git", "xml", string.Empty, userInfos, dataSet));
this.BasePath = repositoryPath;
this.LongPaths = Environment.OSVersion.Platform == PlatformID.Win32NT;
this.cremaHost = this.GetService(typeof(ICremaHost)) as ICremaHost;
this.context = context;
string GenerateRepositoryPath()
{
var repositoryPath = Path.Combine(basePath, context.FullyQualifiedTestClassName);
if (Environment.OSVersion.Platform == PlatformID.Win32NT && repositoryPath.Length > 168)
{
repositoryPath = Path.Combine(basePath, $"{Guid.NewGuid()}");
}
return(repositoryPath);
}
}
public void Test8()
{
var dataSet = new CremaDataSet();
var dataType = dataSet.Types.Add();
var dataTable = dataSet.AddRandomTable();
var derivedTable = dataSet.AddDerivedTable();
var columnCount1 = dataTable.Columns.Count;
var template = new CremaTemplate(dataTable);
var columnCount2 = template.Columns.Count;
var column = template.Columns.RandomOrDefault(item => item.IsKey == false && item.Unique == false);
if (column == null)
{
return;
}
column.Delete();
template.AcceptChanges();
Assert.AreEqual(columnCount1 - 1, template.Columns.Count);
Assert.AreEqual(columnCount1 - 1, dataTable.Columns.Count);
Assert.AreEqual(columnCount1 - 1, derivedTable.Columns.Count);
}
public void CopyChildTable()
{
var dataSet = new CremaDataSet();
var dataTable = dataSet.Tables.Add();
var childTable1 = dataTable.Childs.Add();
var derivedTable = dataTable.Inherit();
derivedTable.CategoryPath = RandomUtility.NextCategoryPath();
var childTable2 = childTable1.Copy();
var derivedChild1 = derivedTable.Childs[childTable1.TableName];
var derivedChild2 = derivedTable.Childs[childTable2.TableName];
Assert.AreEqual(derivedTable.CategoryPath, derivedChild1.CategoryPath);
Assert.AreEqual(derivedTable.CategoryPath, derivedChild2.CategoryPath);
Assert.AreEqual(dataTable.Childs.Count, derivedTable.Childs.Count);
Assert.AreEqual(childTable1.TableName, derivedChild1.TableName);
Assert.AreEqual(childTable2.TableName, derivedChild2.TableName);
Assert.AreEqual(childTable1.Name, derivedChild1.TemplatedParentName);
Assert.AreEqual(childTable2.Name, derivedChild2.TemplatedParentName);
}
public abstract Task PreviewAsync(CremaDataSet dataSet);
public DataBaseTreeViewItemViewModel(CremaDataSet dataSet, ISelector selector)
: base(dataSet, PathUtility.Separator, selector)
{
}
public CremaDataTable ReadData(Authentication authentication)
{
return(this.ReadData(authentication, CremaDataSet.Create(new SignatureDateProvider(authentication.ID))));
}
public void InvokeTablesContentChangedEvent(Authentication authentication, TableContent content, Table[] tables, CremaDataSet dataSet)
{
var eventLog = EventLogBuilder.BuildMany(authentication, this, nameof(InvokeTablesContentChangedEvent), tables);
var comment = EventMessageBuilder.ChangeTableContent(authentication, tables);
this.CremaHost.Debug(eventLog);
this.Repository.Commit(authentication, comment, eventLog);
this.CremaHost.Info(comment);
this.OnTablesChanged(new ItemsEventArgs <ITable>(authentication, tables));
this.Context.InvokeItemsChangedEvent(authentication, tables, dataSet);
}
protected override void OnRelease()
{
base.OnRelease();
this.dataSet = null;
this.views.Clear();
}
public void InvokeTablesCreatedEvent(Authentication authentication, Table[] tables, CremaDataSet dataSet)
{
var args = tables.Select(item => (object)item.TableInfo).ToArray();
var eventLog = EventLogBuilder.BuildMany(authentication, this, nameof(InvokeTablesCreatedEvent), tables);
var comment = EventMessageBuilder.CreateTable(authentication, tables);
this.CremaHost.Debug(eventLog);
this.Repository.Commit(authentication, comment, eventLog);
this.CremaHost.Info(comment);
this.OnTablesCreated(new ItemsCreatedEventArgs <ITable>(authentication, tables, args, dataSet));
this.Context.InvokeItemsCreatedEvent(authentication, tables, args, dataSet);
}
public void InvokeTablesMovedEvent(Authentication authentication, Table[] tables, string[] oldPaths, string[] oldCategoryPaths, CremaDataSet dataSet)
{
var eventLog = EventLogBuilder.BuildMany(authentication, this, nameof(InvokeTablesMovedEvent), tables, oldPaths, oldCategoryPaths);
var comment = EventMessageBuilder.MoveTable(authentication, tables, oldCategoryPaths);
this.CremaHost.Debug(eventLog);
this.Repository.Commit(authentication, comment, eventLog);
this.CremaHost.Info(comment);
this.OnTablesMoved(new ItemsMovedEventArgs <ITable>(authentication, tables, oldPaths, oldCategoryPaths, dataSet));
this.Context.InvokeItemsMovedEvent(authentication, tables, oldPaths, oldCategoryPaths, dataSet);
}
public void InvokeChildTableCreate(Authentication authentication, Table table, CremaDataSet dataSet)
{
this.CremaHost.DebugMethod(authentication, this, nameof(InvokeChildTableCreate), table);
var dataTables = new DataTableCollection(dataSet, this.DataBase);
try
{
dataTables.Modify(this.Repository);
}
catch (Exception e)
{
this.CremaHost.Error(e);
this.Repository.Revert();
throw e;
}
}
public void InvokeTableSetComment(Authentication authentication, Table table, string comment, CremaDataSet dataSet)
{
this.CremaHost.DebugMethod(authentication, this, nameof(InvokeTableSetComment), table, comment);
var dataTables = new DataTableCollection(dataSet, this.DataBase);
var dataTable = dataSet.Tables[table.Name, table.Category.Path];
dataTable.Comment = comment;
try
{
dataTables.Modify(this.Repository);
dataTables.Move(this.Repository);
this.Context.InvokeTableItemChange(authentication, table);
}
catch (Exception e)
{
this.CremaHost.Error(e);
this.Repository.Revert();
throw e;
}
}
public static string[] GetItemPaths(this CremaDataSet dataSet)
{
return(dataSet.ExtendedProperties[nameof(DataBaseSet.ItemPaths)] as string[] ?? new string[] { });
}
public static void SetItemPaths(this CremaDataSet dataSet, string[] itemPaths)
{
dataSet.ExtendedProperties[nameof(DataBaseSet.ItemPaths)] = itemPaths;
}
private void ReadTables(CremaDataSet dataSet, IDataBase dataBase, string filename, string itemNames)
{
var sheetNames = SpreadsheetReader.ReadSheetNames(filename);
var tableInfos = dataBase.Dispatcher.Invoke(() =>
{
var query = from table in dataBase.TableContext.Tables
let tableName2 = SpreadsheetUtility.Ellipsis(table.Name)
join sheetName in sheetNames on tableName2 equals sheetName
where table.Name.GlobMany(itemNames) || table.Path.GlobMany(itemNames)
orderby table.Name
select table.TableInfo;
return(query.ToArray());
});
var typeInfos = dataBase.Dispatcher.Invoke(() =>
{
var query = from table in dataBase.TableContext.Tables
let tableName2 = SpreadsheetUtility.Ellipsis(table.Name)
join sheetName in sheetNames on tableName2 equals sheetName
where table.Name.GlobMany(itemNames) || table.Path.GlobMany(itemNames)
from column in table.TableInfo.Columns
where CremaDataTypeUtility.IsBaseType(column.DataType) == false
let type = dataBase.TypeContext[column.DataType] as IType
where type != null
select type.TypeInfo;
return(query.Distinct().ToArray());
});
foreach (var item in typeInfos)
{
dataSet.Types.Add(item);
}
foreach (var item in tableInfos)
{
if (item.TemplatedParent != string.Empty)
{
continue;
}
if (item.ParentName == string.Empty)
{
dataSet.Tables.Add(item);
}
else
{
dataSet.Tables[item.ParentName].Childs.Add(item);
}
}
foreach (var item in tableInfos)
{
if (item.TemplatedParent != string.Empty && item.ParentName == string.Empty)
{
var dataTable = dataSet.Tables[item.TemplatedParent];
dataTable.Inherit(item.TableName);
}
}
var progress = new ConsoleProgress(this.Out)
{
Style = ConsoleProgressStyle.None
};
using (var reader = new SpreadsheetReader(filename))
{
reader.Read(dataSet, progress);
}
}
