public async Task NewColumnAsync()
{
var items = await this.Template.Dispatcher.InvokeAsync(() => this.Template.Select(item => item.Name).ToArray());
var selectableTypes = await this.Template.Dispatcher.InvokeAsync(() => this.Template.SelectableTypes);
var name = NameUtility.GenerateNewName("Column", items);
var dialog = new NewColumnViewModel(selectableTypes)
{
Name = name,
IsKey = items.Any() == false,
DataType = typeof(string).GetTypeName()
};
if (await dialog.ShowDialogAsync() == true)
{
var member = await this.Template.AddNewAsync(this.authentication);
await member.SetNameAsync(this.authentication, dialog.Name);
await member.SetDataTypeAsync(this.authentication, dialog.DataType);
await member.SetCommentAsync(this.authentication, dialog.Comment);
await member.SetIsKeyAsync(this.authentication, dialog.IsKey);
await this.Template.EndNewAsync(this.authentication, member);
}
}
public static void RenameTest(this IType type, Authentication authentication)
{
var types = type.GetService(typeof(ITypeCollection)) as ITypeCollection;
var newName = NameUtility.GenerateNewName(RandomUtility.NextIdentifier(), types.Select(item => item.Name));
type.Rename(authentication, newName);
}
private static void FillColumns(CremaDataTable diffTable, CremaDataTable dataTable, List <DiffPiece> lines)
{
var index = 0;
foreach (var item in lines)
{
var diffColumn = diffTable.Columns.Add();
if (item.Text != null && dataTable != null)
{
var dataColumn = dataTable.Columns[index];
diffColumn.ColumnName = dataColumn.ColumnName;
diffColumn.CopyFrom(dataColumn);
index++;
}
else
{
diffColumn.ColumnName = GenerateDummyName();
}
DiffUtility.SetDiffState(diffColumn, (DiffState)item.Type);
}
string GenerateDummyName()
{
return(NameUtility.GenerateNewName(DiffUtility.DiffDummyKey, diffTable.Columns.Select(item => item.ColumnName)));
}
}
public CremaDataTable Inherit()
{
var tables = this.DataSet != null ? this.DataSet.Tables : Enumerable.Empty <CremaDataTable>();
var tableName = NameUtility.GenerateNewName("DerivedTable", tables.Select(item => item.TableName));
return(this.Inherit(tableName));
}
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();
}
public static async Task GenerateStandardFlagsAsync(this ITypeCategory category, Authentication authentication)
{
var types = category.GetService(typeof(ITypeCollection)) as ITypeCollection;
var typeNames = await types.Dispatcher.InvokeAsync(() => types.Select(item => item.Name).ToArray());
var newName = NameUtility.GenerateNewName("Flag", typeNames);
var template = await category.AddNewTypeAsync(authentication);
await template.SetTypeNameAsync(authentication, newName);
await template.SetIsFlagAsync(authentication, true);
await template.SetCommentAsync(authentication, "Standard Flag");
await template.AddMemberAsync(authentication, "None", 0, "None Value");
await template.AddMemberAsync(authentication, "A", 1, "A Value");
await template.AddMemberAsync(authentication, "B", 2, "B Value");
await template.AddMemberAsync(authentication, "C", 4, "C Value");
await template.AddMemberAsync(authentication, "D", 8, "D Value");
await template.AddMemberAsync(authentication, "AC", 1 | 4, "AC Value");
await template.AddMemberAsync(authentication, "ABC", 1 | 2 | 4, "AC Value");
await template.AddMemberAsync(authentication, "BD", 2 | 8, "AC Value");
await template.AddMemberAsync(authentication, "All", 1 | 2 | 4 | 8, "All Value");
await template.EndEditAsync(authentication);
}
public InternalDataColumn AddColumn()
{
var columnNames = from DataColumn item in this.Columns select item.ColumnName;
var columnName = NameUtility.GenerateNewName(columnNameString, columnNames.ToArray());
return(this.AddColumn(columnName));
}
public InternalDataTable AddChild()
{
var childNames = from item in this.ChildItems select item.LocalName;
var childName = NameUtility.GenerateNewName(childNameString, childNames.ToArray());
return(this.AddChild(childName));
}
public static Task <string> GenerateNewCategoryNameAsync(this ITableCategory tableCategory, string name)
{
return(tableCategory.Dispatcher.InvokeAsync(() =>
{
var names = tableCategory.Categories.Select(item => item.Name);
return NameUtility.GenerateNewName(name, names);
}));
}
public CremaDataTable Copy()
{
var tables = this.Parent != null ? this.Parent.Childs : (this.DataSet != null ? this.DataSet.Tables : Enumerable.Empty <CremaDataTable>());
var tableName = NameUtility.GenerateNewName("CopiedTable", tables.Select(item => item.TableName));
var name = CremaDataTable.GenerateName(this.ParentName, tableName);
return(this.Copy(name));
}
public static void RenameTest(this ITypeCategory category, Authentication authentication)
{
Assert.AreNotEqual(null, category.Parent);
var parent = category.Parent;
var newName = NameUtility.GenerateNewName(RandomUtility.NextIdentifier(), parent.Categories.Select(item => item.Name));
category.Rename(authentication, newName);
}
public void Add(CremaDataType type)
{
this.ValidateAdd(type);
if (type.TypeName == string.Empty)
{
type.TypeName = NameUtility.GenerateNewName("Type", this.Select(item => item.TypeName).ToArray());
}
this.tables.Add(type.InternalObject);
}
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);
}
public static bool GenerateUser(this IUserContext context, Authentication authentication)
{
var category = context.Categories.Random();
var newID = NameUtility.GenerateNewName("Test", context.Users.Select(item => item.ID).ToArray());
var newName = newID.Replace("Test", "테스트");
category.AddNewUser(authentication, newID, null, newName, Authority.Member);
return(true);
}
protected override CremaDataType CreateSource(Authentication authentication)
{
var newName = NameUtility.GenerateNewName("Type", this.Types.Select((Type item) => item.Name).ToArray());
var dataSet = CremaDataSet.Create(new SignatureDateProvider(authentication.ID));
var dataType = dataSet.Types.Add();
dataType.TypeName = newName;
dataType.CategoryPath = this.category.Path;
return(dataType);
}
public async Task CreateAsync()
{
var authentication = this.CommandContext.GetAuthentication(this);
var category = await this.GetCategoryAsync(this.CategoryPath ?? this.GetCurrentDirectory());
var typeNames = await this.GetTypeNamesAsync();
var template = await category.AddNewTypeAsync(authentication);
var typeName = NameUtility.GenerateNewName("Type", typeNames);
var typeInfo = JsonTypeInfo.Default;
typeInfo.TypeName = typeName;
try
{
if (JsonEditorHost.TryEdit(ref typeInfo) == false)
{
return;
}
if (this.CommandContext.ReadYesOrNo($"do you want to create type '{typeInfo.TypeName}'?") == false)
{
return;
}
await template.SetTypeNameAsync(authentication, typeInfo.TypeName);
await template.SetIsFlagAsync(authentication, typeInfo.IsFlag);
await template.SetCommentAsync(authentication, typeInfo.Comment);
foreach (var item in typeInfo.Members)
{
var member = await template.AddNewAsync(authentication);
await member.SetNameAsync(authentication, item.Name);
await member.SetValueAsync(authentication, item.Value);
await member.SetCommentAsync(authentication, item.Comment);
await template.EndNewAsync(authentication, member);
}
await template.EndEditAsync(authentication);
template = null;
}
finally
{
if (template != null)
{
await template.CancelEditAsync(authentication);
}
}
}
public TypeMember(TypeTemplateBase template, DataTable table)
: base(template.Domain, table)
{
this.template = template;
var query = from DataRow item in table.Rows
select item.Field <string>("Name");
var newName = NameUtility.GenerateNewName("Type", query);
this.SetField(null, "Name", newName);
}
protected override async Task <CremaDataType> CreateSourceAsync(Authentication authentication)
{
var dataSet = await this.category.ReadDataForNewTemplateAsync(authentication);
var typeName = NameUtility.GenerateNewName(nameof(Type), this.Types.Select((Type item) => item.Name).ToArray());
var dataType = dataSet.Types.Add();
dataType.TypeName = typeName;
dataType.CategoryPath = this.category.Path;
return(dataType);
}
public TableColumn(TableTemplateBase template, DataTable table)
: base(template.Domain, table)
{
this.template = template;
var query = from DataRow item in table.Rows
where (item.RowState == DataRowState.Deleted || item.RowState == DataRowState.Detached) == false
select item.Field <string>("ColumnName");
var newName = NameUtility.GenerateNewName("Column", query);
this.SetField(null, "ColumnName", newName);
}
public static void RenameTest(this ITable table, Authentication authentication)
{
if (table.Parent == null)
{
var tables = table.GetService(typeof(ITableCollection)) as ITableCollection;
var newName = NameUtility.GenerateNewName(RandomUtility.NextIdentifier(), tables.Select(item => item.Name));
table.Rename(authentication, newName);
}
else
{
var parent = table.Parent;
var newName = NameUtility.GenerateNewName(RandomUtility.NextIdentifier(), parent.Childs.Select(item => item.Name));
table.Rename(authentication, newName);
}
}
public void TypeRenameFailTest()
{
cremaHost.Dispatcher.Invoke(() =>
{
try
{
var types = this.type.GetService(typeof(ITypeCollection)) as ITypeCollection;
var newName = NameUtility.GenerateNewName(RandomUtility.NextIdentifier(), types.Select(item => item.Name));
this.type.Rename(this.guest, newName);
Assert.Fail("Rename");
}
catch (PermissionDeniedException)
{
}
});
}
public void Create()
{
var authentication = this.CommandContext.GetAuthentication(this);
var category = this.GetCategory(this.CategoryPath ?? this.GetCurrentDirectory());
var typeNames = this.GetTypeNames();
var template = category.Dispatcher.Invoke(() => category.NewType(authentication));
var typeName = NameUtility.GenerateNewName("Type", typeNames);
var typeInfo = JsonTypeInfo.Default;
typeInfo.TypeName = typeName;
try
{
if (JsonEditorHost.TryEdit(ref typeInfo) == false)
{
return;
}
if (this.CommandContext.ReadYesOrNo($"do you want to create type '{typeInfo.TypeName}'?") == false)
{
return;
}
template.Dispatcher.Invoke(() =>
{
template.SetTypeName(authentication, typeInfo.TypeName);
template.SetIsFlag(authentication, typeInfo.IsFlag);
template.SetComment(authentication, typeInfo.Comment);
foreach (var item in typeInfo.Members)
{
var member = template.AddNew(authentication);
member.SetName(authentication, item.Name);
member.SetValue(authentication, item.Value);
member.SetComment(authentication, item.Comment);
template.EndNew(authentication, member);
}
template.EndEdit(authentication);
template = null;
});
}
finally
{
if (template != null)
{
template.Dispatcher.Invoke(() => template.CancelEdit(authentication));
}
}
}
public static async Task <TypeMember> CreateAsync(Authentication authentication, TypeTemplateBase template, DataTable table)
{
var domain = template.Domain;
var tuple = await domain.DataDispatcher.InvokeAsync(() =>
{
var member = new TypeMember(template, table);
var query = from DataRow item in table.Rows
select item.Field <string>(CremaSchema.Name);
var newName = NameUtility.GenerateNewName("Member", query);
return(member, newName);
});
await tuple.member.SetFieldAsync(authentication, CremaSchema.Name, tuple.newName);
return(tuple.member);
}
public InternalDataTable AddTable()
{
var name = NameUtility.GenerateNewName("Table", GetTableNames());
return(this.AddTable(name));
IEnumerable <string> GetTableNames()
{
foreach (var item in this.Tables)
{
if (item is InternalDataTable tableItem)
{
yield return(tableItem.Name);
}
}
}
}
public static void RenameFailTest <T>(ITable table, Authentication authentication) where T : Exception
{
Assert.AreNotEqual(null, table.Parent);
table.Dispatcher.Invoke(() =>
{
try
{
var parent = table.Parent;
var newName = NameUtility.GenerateNewName(RandomUtility.NextIdentifier(), parent.Childs.Select(item => item.Name));
table.Rename(authentication, newName);
Assert.Fail("RenameFailTest");
}
catch (T)
{
}
});
}
public static void RenameFailTest <T>(ITable table, Authentication authentication) where T : Exception
{
Assert.AreEqual(null, table.Parent);
table.Dispatcher.Invoke(() =>
{
try
{
var tables = table.GetService(typeof(ITableCollection)) as ITableCollection;
var newName = NameUtility.GenerateNewName(RandomUtility.NextIdentifier(), tables.Select(item => item.Name));
table.Rename(authentication, newName);
Assert.Fail("RenameFailTest");
}
catch (T)
{
}
});
}
public static void TableRenameTest(this IDataBase dataBase, Authentication authentication)
{
dataBase.Dispatcher.Invoke(() =>
{
var tables = dataBase.GetService(typeof(ITableCollection)) as ITableCollection;
var table = tables.RandomOrDefault(item => item.TemplatedParent == null);
if (table == null)
{
return;
}
var newName = NameUtility.GenerateNewName(RandomUtility.NextIdentifier(), tables.Select(item => item.Name));
table.Rename(authentication, newName);
});
}
public static async Task <TableColumn> CreateAsync(Authentication authentication, TableTemplateBase template, DataTable table)
{
var domain = template.Domain;
var tuple = await domain.DataDispatcher.InvokeAsync(() =>
{
var column = new TableColumn(template, table);
var query = from DataRow item in table.Rows
where (item.RowState == DataRowState.Deleted || item.RowState == DataRowState.Detached) == false
select item.Field <string>(CremaSchema.ColumnName);
var newName = NameUtility.GenerateNewName("Column", query);
return(column, newName);
});
await tuple.column.SetFieldAsync(authentication, CremaSchema.ColumnName, tuple.newName);
return(tuple.column);
}
public static void GenerateStandardFlags(this ITypeCategory category, Authentication authentication)
{
var newName = NameUtility.GenerateNewName("Flag", category.DataBase.TypeContext.Types.Select(item => item.Name).ToArray());
var template = category.NewType(authentication);
template.SetTypeName(authentication, newName);
template.SetIsFlag(authentication, true);
template.SetComment(authentication, "Standard Flag");
template.AddMember(authentication, "None", 0, "None Value");
template.AddMember(authentication, "A", 1, "A Value");
template.AddMember(authentication, "B", 2, "B Value");
template.AddMember(authentication, "C", 4, "C Value");
template.AddMember(authentication, "D", 8, "D Value");
template.AddMember(authentication, "AC", 1 | 4, "AC Value");
template.AddMember(authentication, "ABC", 1 | 2 | 4, "AC Value");
template.AddMember(authentication, "BD", 2 | 8, "AC Value");
template.AddMember(authentication, "All", 1 | 2 | 4 | 8, "All Value");
template.EndEdit(authentication);
}
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,
};
}