public void Create(string categoryPath = null)
{
var schema = JsonSchemaUtility.CreateSchema(typeof(JsonUserInfo));
schema.SetEnums(nameof(JsonUserInfo.CategoryPath), this.GetCategoryPaths());
var userInfo = JsonUserInfo.Default;
userInfo.CategoryPath = categoryPath;
if (JsonEditorHost.TryEdit(ref userInfo, schema) == false)
{
return;
}
this.UserContext.Dispatcher.Invoke(() =>
{
categoryPath = userInfo.CategoryPath ?? this.CommandContext.Path;
var category = this.UserContext.Dispatcher.Invoke(() => this.GetCategory(categoryPath));
var userID = userInfo.UserID;
var password = StringUtility.ToSecureString(userInfo.Password);
var userName = userInfo.UserName;
var authority = (Authority)Enum.Parse(typeof(Authority), userInfo.Authority);
var authentication = this.CommandContext.GetAuthentication(this);
category.AddNewUser(authentication, userID, password, userName, authority);
});
}
private async Task EditMemberAsync()
{
var value = new JsonColumnInfo();
var column = this.Template.Dispatcher.Invoke(() => this.Template[this.ColumnName]);
var dataTypes = this.Template.Dispatcher.Invoke(() => this.Template.SelectableTypes);
var columnCount = this.Template.Dispatcher.Invoke(() => this.Template.Count);
this.Template.Dispatcher.Invoke(() =>
{
value.Name = column.Name;
value.Index = column.Index;
value.IsKey = column.IsKey;
value.DataType = column.DataType;
value.Comment = column.Comment;
});
var schema = JsonSchemaUtility.CreateSchema(typeof(JsonColumnInfo));
var typeSchema = schema.Properties[nameof(JsonColumnInfo.DataType)];
typeSchema.SetEnums(dataTypes);
var indexSchema = schema.Properties[nameof(JsonColumnInfo.Index)];
indexSchema.Minimum = 0;
indexSchema.Maximum = columnCount - 1;
using var editor = new JsonEditorHost(value, schema);
if (editor.Execute() == true)
{
value = editor.Read <JsonColumnInfo>();
if (column.Name != value.Name)
{
await column.SetNameAsync(this.Authentication, value.Name);
}
}
}
private void EditMember()
{
var value = new JsonTypeMemberInfo();
var member = this.Template.Dispatcher.Invoke(() => this.Template[this.MemberName]);
var memberCount = this.Template.Dispatcher.Invoke(() => this.Template.Count);
this.Template.Dispatcher.Invoke(() =>
{
value.Name = member.Name;
value.Index = member.Index;
value.Value = member.Value;
value.Comment = member.Comment;
});
var schema = JsonSchemaUtility.CreateSchema(typeof(JsonTypeMemberInfo));
var indexSchema = schema.Properties[nameof(JsonTypeMemberInfo.Index)];
indexSchema.Minimum = 0;
indexSchema.Maximum = memberCount - 1;
using (var editor = new JsonEditorHost(value, schema))
{
if (editor.Execute() == true)
{
value = editor.Read <JsonTypeMemberInfo>();
member.Dispatcher.Invoke(() =>
{
if (member.Name != value.Name)
{
member.SetName(this.Authentication, value.Name);
}
if (member.Value != value.Value)
{
member.SetValue(this.Authentication, value.Value);
}
if (member.Comment != value.Comment)
{
member.SetComment(this.Authentication, value.Comment);
}
if (member.Index != value.Index)
{
member.SetIndex(this.Authentication, value.Index);
}
});
}
}
}
internal JSchema CreateSchema(string dataType)
{
if (CremaDataTypeUtility.IsBaseType(dataType) == true)
{
return(JsonSchemaUtility.GetSchema(CremaDataTypeUtility.GetType(dataType)));
}
else
{
var memberNames = this.Content.Dispatcher.Invoke(() =>
{
var table = this.Content.Table;
var typeContext = table.GetService(typeof(ITypeContext)) as ITypeContext;
var type = typeContext[dataType] as IType;
return(type.TypeInfo.Members.Select(i => i.Name).ToArray());
});
return(JsonSchemaUtility.CreateSchema(memberNames));
}
}
public async Task CreateAsync()
{
var schema = JsonSchemaUtility.CreateSchema(typeof(JsonUserInfo));
schema.SetEnums(nameof(JsonUserInfo.CategoryPath), await this.GetCategoryPathsAsync());
var userInfo = JsonUserInfo.Default;
userInfo.CategoryPath = this.CategoryPath;
if (JsonEditorHost.TryEdit(ref userInfo, schema) == false)
{
return;
}
var category = await this.GetCategoryAsync(this.CategoryPath ?? this.CommandContext.Path);
var userID = userInfo.UserID;
var password = StringUtility.ToSecureString(userInfo.Password);
var userName = userInfo.UserName;
var authority = (Authority)Enum.Parse(typeof(Authority), userInfo.Authority);
var authentication = this.CommandContext.GetAuthentication(this);
await category.AddNewUserAsync(authentication, userID, password, userName, authority);
}
public static bool EditColumns(ITableTemplate template, Authentication authentication)
{
var columnCount = template.Dispatcher.Invoke(() => template.Count);
var dataTypes = template.Dispatcher.Invoke(() => template.SelectableTypes);
var columnList = new List <JsonColumnInfos.ItemInfo>(columnCount);
var idToColumn = new Dictionary <Guid, ITableColumn>(columnCount);
template.Dispatcher.Invoke(() =>
{
foreach (var item in template)
{
var column = new JsonColumnInfos.ItemInfo()
{
ID = Guid.NewGuid(),
Name = item.Name,
IsKey = item.IsKey,
DataType = item.DataType,
Comment = item.Comment,
IsUnique = item.IsUnique,
AutoIncrement = item.AutoIncrement,
DefaultValue = item.DefaultValue,
Tags = (string)item.Tags,
IsReadOnly = item.IsReadOnly,
AllowNull = item.AllowNull,
};
idToColumn.Add(column.ID, item);
columnList.Add(column);
}
});
var schema = JsonSchemaUtility.CreateSchema(typeof(JsonColumnInfos));
var itemsSchema = schema.Properties[nameof(JsonColumnInfos.Items)];
var itemSchema = itemsSchema.Items.First();
var dataTypeSchema = itemSchema.Properties[nameof(JsonColumnInfos.ItemInfo.DataType)];
dataTypeSchema.SetEnums(dataTypes);
var tagSchema = itemSchema.Properties[nameof(JsonColumnInfos.ItemInfo.Tags)];
tagSchema.SetEnums(TagInfoUtility.Names);
var columns = new JsonColumnInfos()
{
Items = columnList.ToArray()
};
using (var editor = new JsonEditorHost(columns, schema))
{
if (editor.Execute() == false)
{
return(false);
}
columns = editor.Read <JsonColumnInfos>();
}
template.Dispatcher.Invoke(() =>
{
foreach (var item in idToColumn.Keys.ToArray())
{
if (columns.Items.Any(i => i.ID == item) == false)
{
var column = idToColumn[item];
column.Delete(authentication);
idToColumn.Remove(item);
}
}
for (var i = 0; i < columns.Items.Length; i++)
{
var item = columns.Items[i];
if (item.ID == Guid.Empty)
{
var column = template.AddNew(authentication);
item = InitializeFields(authentication, item, column);
template.EndNew(authentication, column);
item.ID = Guid.NewGuid();
idToColumn.Add(item.ID, column);
columns.Items[i] = item;
}
else if (idToColumn.ContainsKey(item.ID) == true)
{
var column = idToColumn[item.ID];
SetFields(authentication, item, column);
}
else
{
throw new InvalidOperationException($"{item.ID} is not existed column.");
}
}
for (var i = 0; i < columns.Items.Length; i++)
{
var item = columns.Items[i];
var column = idToColumn[item.ID];
column.SetIndex(authentication, i);
}
});
return(true);
}
public void Create()
{
var authentication = this.CommandContext.GetAuthentication(this);
var category = this.GetCategory(this.CategoryPath ?? this.GetCurrentDirectory());
var tableNames = this.GetTableNames();
var template = category.Dispatcher.Invoke(() => category.NewTable(authentication));
var dataTypes = template.Dispatcher.Invoke(() => template.SelectableTypes);
var tableName = NameUtility.GenerateNewName("Table", tableNames);
var tableInfo = JsonTableInfo.Default;
if (tableInfo.TableName == string.Empty)
{
tableInfo.TableName = tableName;
}
var schema = JsonSchemaUtility.GetSchema(typeof(JsonTableInfo));
var itemsSchema = schema.Properties[nameof(JsonTableInfo.Columns)];
var itemSchema = itemsSchema.Items.First();
itemSchema.SetEnums(nameof(JsonTableInfo.JsonTableColumnInfo.DataType), dataTypes);
itemSchema.SetEnums(nameof(JsonTableInfo.JsonTableColumnInfo.Tags), TagInfoUtility.Names);
try
{
if (JsonEditorHost.TryEdit(ref tableInfo, schema) == false)
{
return;
}
if (this.CommandContext.ReadYesOrNo($"do you want to create table '{tableInfo.TableName}'?") == false)
{
return;
}
template.Dispatcher.Invoke(SetData);
template = null;
}
finally
{
if (template != null)
{
template.Dispatcher.Invoke(() => template.CancelEdit(authentication));
}
}
void SetData()
{
template.SetTableName(authentication, tableInfo.TableName);
template.SetTags(authentication, (TagInfo)tableInfo.Tags);
template.SetComment(authentication, tableInfo.Comment);
foreach (var item in tableInfo.Columns)
{
var column = template.AddNew(authentication);
column.SetName(authentication, item.Name);
column.SetIsKey(authentication, item.IsKey);
column.SetComment(authentication, item.Comment);
column.SetDataType(authentication, item.DataType);
column.SetIsUnique(authentication, item.IsUnique);
column.SetAutoIncrement(authentication, item.AutoIncrement);
column.SetDefaultValue(authentication, item.DefaultValue);
column.SetTags(authentication, (TagInfo)item.Tags);
column.SetIsReadOnly(authentication, item.IsReadOnly);
template.EndNew(authentication, column);
}
template.EndEdit(authentication);
}
}
public async Task CreateAsync()
{
var authentication = this.CommandContext.GetAuthentication(this);
var tableNames = this.GetTableNamesAsync();
var template = await CreateTemplateAsync();
var dataTypes = template.Dispatcher.Invoke(() => template.SelectableTypes);
var tableName = template.Dispatcher.Invoke(() => template.TableName);
var tableInfo = JsonTableInfo.Default;
if (tableInfo.TableName == string.Empty)
{
tableInfo.TableName = tableName;
}
var schema = JsonSchemaUtility.GetSchema(typeof(JsonTableInfo));
var itemsSchema = schema.Properties[nameof(JsonTableInfo.Columns)];
var itemSchema = itemsSchema.Items.First();
itemSchema.SetEnums(nameof(JsonTableInfo.JsonTableColumnInfo.DataType), dataTypes);
itemSchema.SetEnums(nameof(JsonTableInfo.JsonTableColumnInfo.Tags), TagInfoUtility.Names);
try
{
if (JsonEditorHost.TryEdit(ref tableInfo, schema) == false)
{
return;
}
if (this.CommandContext.ReadYesOrNo($"do you want to create table '{tableInfo.TableName}'?") == false)
{
return;
}
await SetDataAsync();
template = null;
}
finally
{
if (template != null)
{
await template.CancelEditAsync(authentication);
}
}
async Task <ITableTemplate> CreateTemplateAsync()
{
if (this.ParentPath == string.Empty)
{
var category = await this.GetCategoryAsync(this.GetCurrentDirectory());
return(await category.AddNewTableAsync(authentication));
}
else if (NameValidator.VerifyCategoryPath(this.ParentPath) == true)
{
var category = await this.GetCategoryAsync(this.ParentPath);
return(await category.AddNewTableAsync(authentication));
}
else if (await this.GetTableAsync(this.ParentPath) is ITable table)
{
return(await table.NewTableAsync(authentication));
}
else
{
throw new NotImplementedException();
}
}
async Task SetDataAsync()
{
await template.SetTableNameAsync(authentication, tableInfo.TableName);
await template.SetTagsAsync(authentication, (TagInfo)tableInfo.Tags);
await template.SetCommentAsync(authentication, tableInfo.Comment);
foreach (var item in tableInfo.Columns)
{
var column = await template.AddNewAsync(authentication);
await column.SetNameAsync(authentication, item.Name);
await column.SetIsKeyAsync(authentication, item.IsKey);
await column.SetCommentAsync(authentication, item.Comment);
await column.SetDataTypeAsync(authentication, item.DataType);
await column.SetIsUniqueAsync(authentication, item.IsUnique);
await column.SetAutoIncrementAsync(authentication, item.AutoIncrement);
await column.SetDefaultValueAsync(authentication, item.DefaultValue);
await column.SetTagsAsync(authentication, (TagInfo)item.Tags);
await column.SetIsReadOnlyAsync(authentication, item.IsReadOnly);
await template.EndNewAsync(authentication, column);
}
await template.EndEditAsync(authentication);
}
}
