public void NewWithNameAndInvalidType_Fail() { var attributeName = RandomUtility.NextIdentifier(); var attributeType = typeof(string).Assembly.GetTypes().Random(item => CremaDataTypeUtility.IsBaseType(item) == false); new CremaAttribute(attributeName, attributeType); }
public override DataTemplate SelectTemplate(object item, DependencyObject container) { if (container is FrameworkElement fe) { if (item is NewRowItemViewModel viewModel) { if (CremaDataTypeUtility.IsBaseType(viewModel.DataType) == true) { var dataType = CremaDataTypeUtility.GetType(viewModel.DataType); return((DataTemplate)fe.FindResource(dataType.FullName)); } else { if (viewModel.IsFlag == true) { return((DataTemplate)fe.FindResource("CremaFlagTypeSelector")); } return((DataTemplate)fe.FindResource("CremaTypeSelector")); } } else if (item is NewRowParentItemViewModel parentViewModel) { return((DataTemplate)fe.FindResource("ParentSelector")); } } return(base.SelectTemplate(item, container)); }
public static string GetRandomString(this ITableColumn tableColumn) { if (tableColumn.DefaultValue != null && RandomUtility.Next(3) == 0) { return(null); } else if (tableColumn.AllowNull == true && RandomUtility.Next(4) == 0) { return(null); } else { var template = tableColumn.Template; var dataType = tableColumn.DataType; if (CremaDataTypeUtility.IsBaseType(dataType) == false) { var type = template.GetType(dataType); return(type.GetRandomString()); } else { var value = RandomUtility.Next(CremaDataTypeUtility.GetType(dataType)); return(CremaConvert.ChangeType(value, typeof(string)) as string); } } }
protected override void OnExecute() { var tableInfo = this.Content.Dispatcher.Invoke(() => this.Content.Table.TableInfo); var keys = tableInfo.Columns.Where(item => item.IsKey).ToArray(); var schema = this.CreateSchema(tableInfo.Columns); var fieldList = new List <object>(); for (var i = 0; i < this.Keys.Length; i++) { var key = keys[i]; var keyText = this.Keys[i]; var type = CremaDataTypeUtility.IsBaseType(key.DataType) ? CremaDataTypeUtility.GetType(key.DataType) : typeof(string); var value = CremaConvert.ChangeType(keyText, type); fieldList.Add(value); } var authentication = this.CommandContext.GetAuthentication(this); var tableRow = this.Content.Dispatcher.Invoke(() => this.Content.Find(authentication, fieldList.ToArray())); var terminal = new Terminal(); if (terminal.ReadString("type 'remove':") != "remove") { return; } this.Content.Dispatcher.Invoke(() => { tableRow.Delete(authentication); }); }
public static string GenerateSchemaTypeName(string typeName) { if (CremaDataTypeUtility.IsBaseType(typeName) == true) { return(string.Format("{0}:{1}", "xs", typeName)); } return(typeName); }
private object GetDefaultValue(ColumnInfo columnInfo) { if (columnInfo.DefaultValue != null && CremaDataTypeUtility.IsBaseType(columnInfo.DataType) == true) { var type = CremaDataTypeUtility.GetType(columnInfo.DataType); return(CremaConvert.ChangeType(columnInfo.DefaultValue, type)); } return(columnInfo.DefaultValue); }
public static CodeTypeReference GetCodeType(this ColumnInfo columnInfo, CodeType codeType) { if (CremaDataTypeUtility.IsBaseType(columnInfo.DataType) == true) { return(new CodeTypeReference(CremaDataTypeUtility.GetType(columnInfo.DataType))); } var itemName = new ItemName(columnInfo.DataType); return(Utility.GenerateCodeType(TypeNamespace, itemName.Name)); }
public static void Copy(object sourceItem, object destItem, bool isBeingEdited) { if (HasError(sourceItem) == true) { throw new ArgumentException(); } if (destItem is IEditableObject editable) { try { if (isBeingEdited == false) { editable.BeginEdit(); } if (destItem is ICustomTypeDescriptor descriptor1 && sourceItem is ICustomTypeDescriptor descriptor2) { var props1 = descriptor1.GetProperties(); var props2 = descriptor2.GetProperties(); foreach (PropertyDescriptor prop2 in props2) { var prop1 = props1[prop2.Name]; if (prop1 == null) { continue; } if (prop1.Name == CremaSchema.__RelationID__ || prop1.Name == CremaSchema.__ParentID__) { continue; } if (prop1.IsReadOnly == false && CremaDataTypeUtility.IsBaseType(prop1.PropertyType)) { prop1.SetValue(destItem, prop2.GetValue(sourceItem)); } } } if (isBeingEdited == false) { editable.EndEdit(); } } catch { if (isBeingEdited == false) { editable.CancelEdit(); } throw; } } }
static bool Predicate(CremaTemplateColumn item) { if (CremaDataTypeUtility.IsBaseType(item.DataTypeName) == false) { return(false); } if (item.AutoIncrement == true) { return(false); } return(true); }
public static void Empty(object dataItem, bool isBeingEdited) { if (dataItem is IEditableObject editable) { try { if (isBeingEdited == false) { editable.BeginEdit(); } if (dataItem is ICustomTypeDescriptor descriptor) { var props = descriptor.GetProperties(); for (var i = 0; i < props.Count; i++) { var prop = props[i]; if (prop.IsBrowsable == false || prop.Name == CremaSchema.Index) { continue; } if (prop.Name == CremaSchema.__RelationID__ || prop.Name == CremaSchema.__ParentID__) { continue; } if (CremaDataTypeUtility.IsBaseType(prop.PropertyType) == false) { continue; } prop.ResetValue(dataItem); } SetItemEnabled(dataItem, false); } if (isBeingEdited == false) { editable.EndEdit(); } } catch { if (isBeingEdited == false) { editable.CancelEdit(); } throw; } } }
public static CodeTypeReference GetCodeType(this ColumnInfo columnInfo) { if (CremaDataTypeUtility.IsBaseType(columnInfo.DataType) == true) { return(new CodeTypeReference(CremaDataTypeUtility.GetType(columnInfo.DataType))); } var itemName = new ItemName(columnInfo.DataType); if (string.IsNullOrEmpty(TypeNamespace) == true) { return(new CodeTypeReference(itemName.Name)); } return(new CodeTypeReference(TypeNamespace + "." + itemName.Name)); }
private static object GetRandomValue(this ITableRow tableRow, string columnName) { var content = tableRow.Content; var table = content.Table; var columnInfo = table.TableInfo.Columns.Where(item => item.Name == columnName).First(); if (CremaDataTypeUtility.IsBaseType(columnInfo.DataType) == true) { var type = CremaDataTypeUtility.GetType(columnInfo.DataType); return(RandomUtility.Next(type)); } else { var typeContext = table.GetService(typeof(ITypeContext)) as ITypeContext; var type = typeContext[columnInfo.DataType] as IType; return(type.GetRandomValue()); } }
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 static CodeTypeReference GetPropertyType(this ColumnInfo columnInfo) { CodeTypeReference codeTypeRef = null; if (CremaDataTypeUtility.IsBaseType(columnInfo.DataType) == true) { var runtimeType = CremaDataTypeUtility.GetType(columnInfo.DataType); codeTypeRef = new CodeTypeReference(runtimeType); if (runtimeType == typeof(string)) { codeTypeRef.SetCodeType(CodeType.Reference | CodeType.Const); } } else { var itemName = new ItemName(columnInfo.DataType); codeTypeRef = Utility.GenerateCodeType(TypeNamespace, itemName.Name); } return(codeTypeRef); }
private static async Task <object> GetRandomValueAsync(this ITableRow tableRow, string columnName) { var content = tableRow.Content; var table = content.Table; var tableInfo = await table.Dispatcher.InvokeAsync(() => table.TableInfo); var columnInfo = tableInfo.Columns.Where(item => item.Name == columnName).First(); if (CremaDataTypeUtility.IsBaseType(columnInfo.DataType) == true) { var type = CremaDataTypeUtility.GetType(columnInfo.DataType); return(RandomUtility.Next(type)); } else { var typeContext = table.GetService(typeof(ITypeContext)) as ITypeContext; var type = await typeContext.Dispatcher.InvokeAsync(() => typeContext[columnInfo.DataType] as IType); return(await type.GetRandomValueAsync()); } }
public static bool HasError(object item) { if (item is IDataErrorInfo errorInfo) { if (errorInfo.Error != string.Empty) { return(true); } if (item is ICustomTypeDescriptor descriptor) { foreach (PropertyDescriptor prop in descriptor.GetProperties()) { if (CremaDataTypeUtility.IsBaseType(prop.PropertyType) == true && errorInfo[prop.Name] != string.Empty) { return(true); } } } } return(false); }
public static async Task <string> GetRandomStringAsync(this ITableColumn tableColumn) { if (tableColumn.DefaultValue != null && RandomUtility.Next(3) == 0) { return(null); } else if (tableColumn.AllowNull == true && RandomUtility.Next(4) == 0) { return(null); } else { var template = tableColumn.Template; var dataType = tableColumn.DataType; if (CremaDataTypeUtility.IsBaseType(dataType) == false) { try { var domain = template.Domain; var dataBase = domain.GetService(typeof(IDataBase)) as IDataBase; var typeCollection = dataBase.GetService(typeof(ITypeCollection)) as ITypeCollection; var typeName = new ItemName(dataType); var type = await typeCollection.GetTypeAsync(typeName.Name, typeName.CategoryPath); return(await type.GetRandomStringAsync()); } catch (System.NullReferenceException e) { System.Diagnostics.Debugger.Launch(); throw e; } } else { var value = RandomUtility.Next(CremaDataTypeUtility.GetType(dataType)); return(CremaConvert.ChangeType(value, typeof(string)) as string); } } }
public void SetNullDefaultValue() { this.column = this.template.Columns.Random(Predicate); var dataType = CremaDataTypeUtility.GetType(this.column.DataTypeName); var defaultValue = RandomUtility.Next(dataType); this.column.DefaultValue = defaultValue; this.column.DefaultValue = null; Assert.AreEqual(DBNull.Value, this.column.DefaultValue); bool Predicate(CremaTemplateColumn item) { if (CremaDataTypeUtility.IsBaseType(item.DataTypeName) == false) { return(false); } if (item.AutoIncrement == true) { return(false); } return(true); } }
public void SetDataType_Fail() { var newType = typeof(string).Assembly.GetTypes().Random(item => CremaDataTypeUtility.IsBaseType(item) == false); this.attribute.DataType = newType; }
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); } }
public static bool IsCustomType(this ColumnInfo columnInfo) { return(CremaDataTypeUtility.IsBaseType(columnInfo.DataType) == false); }
public void NewWithNullNameAndInvalidType_Fail() { var attributeType = typeof(string).Assembly.GetTypes().Random(item => CremaDataTypeUtility.IsBaseType(item) == false); new CremaAttribute(null, attributeType); }
protected override async Task OnExecuteAsync(CancellationToken cancellationToken) { var tableInfo = this.Content.Dispatcher.Invoke(() => this.Content.Table.TableInfo); var keys = tableInfo.Columns.Where(item => item.IsKey).ToArray(); var schema = this.CreateSchema(tableInfo.Columns); var fieldList = new List <object>(); for (var i = 0; i < this.Keys.Length; i++) { var key = keys[i]; var keyText = this.Keys[i]; var type = CremaDataTypeUtility.IsBaseType(key.DataType) ? CremaDataTypeUtility.GetType(key.DataType) : typeof(string); var value = CremaConvert.ChangeType(keyText, type); fieldList.Add(value); } var fields = new JsonPropertiesInfo(); var authentication = this.CommandContext.GetAuthentication(this); var tableRow = await this.Content.FindAsync(authentication, fieldList.ToArray()); this.Content.Dispatcher.Invoke(() => { foreach (var item in tableInfo.Columns) { var field = tableRow[item.Name]; if (field != null || item.AllowNull == false) { fields.Add(item.Name, field); } } }); var result = fields.Execute(schema); if (result == null) { return; } foreach (var item in fields) { if (result.ContainsKey(item.Key) == false) { await tableRow.SetFieldAsync(authentication, item.Key, DBNull.Value); } } foreach (var item in result) { if (tableInfo.Columns.Any(i => i.Name == item.Key) == false) { continue; } var value1 = tableRow[item.Key]; var value2 = item.Value; if (object.Equals(value1, value2) == true) { continue; } await tableRow.SetFieldAsync(authentication, item.Key, item.Value); } }