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); } }