public static void ModifyRandomRow(this CremaDataTable dataTable)
{
if (RandomUtility.Within(90) == true)
{
var dataRow = dataTable.Rows.RandomOrDefault();
var dataColumn = dataTable.Columns.RandomOrDefault();
if (dataRow != null && dataColumn != null)
{
dataRow.SetRandomValue(dataColumn);
if (RandomUtility.Within(5) == true)
{
dataRow.IsEnabled = RandomUtility.NextBoolean();
}
}
}
else if (RandomUtility.Within(75) == true)
{
AddRandomRow(dataTable);
}
else
{
var dataRow = dataTable.Rows.RandomOrDefault();
if (dataRow != null)
{
if (RandomUtility.Within(50) == true)
{
dataRow.Delete();
}
else
{
dataTable.Rows.Remove(dataRow);
}
}
}
}
public void SetIsUnique(ITableColumn column, TaskContext context)
{
column.Dispatcher.Invoke(() =>
{
var isUnique = RandomUtility.NextBoolean();
if (Verify(isUnique) == false)
{
return;
}
column.SetIsUnique(context.Authentication, isUnique);
});
bool Verify(bool isUnique)
{
if (context.AllowException == true)
{
return(true);
}
if (isUnique == true && column.DataType == typeof(bool).GetTypeName())
{
return(false);
}
var template = column.Template;
if (isUnique == false && column.IsKey == true && template.Count(item => item.IsKey) == 1)
{
return(false);
}
return(true);
}
}
public void SetAutoIncrement(ITableColumn column, TaskContext context)
{
column.Dispatcher.Invoke(() =>
{
var autoIncrement = RandomUtility.NextBoolean();
if (Verify(autoIncrement) == false)
{
return;
}
column.SetAutoIncrement(context.Authentication, autoIncrement);
});
bool Verify(bool autoIncrement)
{
if (context.AllowException == true)
{
return(true);
}
if (autoIncrement == true && CremaDataTypeUtility.CanUseAutoIncrement(column.DataType) == false)
{
return(false);
}
return(true);
}
}
public static void ChangeRow(this ITableContent content, Authentication authentication)
{
var table = content.Table;
var row = content.RandomOrDefault();
if (row == null)
{
return;
}
var types = table.GetService(typeof(ITypeCollection)) as ITypeCollection;
if (RandomUtility.Within(5) == true)
{
row.SetTags(authentication, tags.Random());
}
else if (RandomUtility.Within(5) == true)
{
row.SetIsEnabled(authentication, RandomUtility.NextBoolean());
}
else
{
var columnInfo = table.TableInfo.Columns.Random();
//row.SetField(authentication, columnInfo.Name, TypeContextExtensions.GetRandomValue(types, columnInfo));
}
}
public static void CreateRow(this ITableContent content, Authentication authentication)
{
var table = content.Table;
var parent = content.Parent;
string relationID = null;
if (parent != null && parent.Any() == true)
{
relationID = parent.Random().RelationID;
}
var row = content.AddNew(authentication, relationID);
var types = table.GetService(typeof(ITypeCollection)) as ITypeCollection;
foreach (var item in table.TableInfo.Columns)
{
if (item.AutoIncrement == false)
{
//row.SetField(authentication, item.Name, TypeContextExtensions.GetRandomValue(types, item));
}
}
if (RandomUtility.Within(25) == true)
{
row.SetTags(authentication, tags.Random());
}
if (RandomUtility.Within(25) == true)
{
row.SetIsEnabled(authentication, RandomUtility.NextBoolean());
}
content.EndNew(authentication, row);
}
public static bool GenerateRow(this ITableContent content, Authentication authentication)
{
var row = NewRandomRow(content, authentication);
if (FillFields(row, authentication) == true)
{
if (RandomUtility.Within(25) == true)
{
row.SetTags(authentication, tags.Random());
}
if (RandomUtility.Within(25) == true)
{
row.SetIsEnabled(authentication, RandomUtility.NextBoolean());
}
try
{
content.EndNew(authentication, row);
return(true);
}
catch
{
return(false);
}
}
return(false);
}
public async Task <IType> GetTypeAsync(IDataBase dataBase)
{
var typeFlags = this.TypeFlags;
var typeCollection = dataBase.GetService(typeof(ITypeCollection)) as ITypeCollection;
var typeCategoryCollection = dataBase.GetService(typeof(ITypeCategoryCollection)) as ITypeCategoryCollection;
var typeContext = dataBase.GetService(typeof(ITypeContext)) as ITypeContext;
var type = await typeCollection.GetRandomTypeAsync(typeFlags, this);
if (type is null)
{
var category = await typeCategoryCollection.GetRandomTypeCategoryAsync();
var isFlag = typeFlags.HasFlag(TypeFlags.IsFlag) || RandomUtility.NextBoolean() == true;
var newType = await category.GenerateTypeAsync(Authentication.System, isFlag);
if (newType is null)
{
throw new InvalidOperationException();
}
if (typeFlags.HasFlag(TypeFlags.IsReferenced) == true)
{
var tableFilter = new TableFilter(TableFlags.Public | TableFlags.NotBeingEdited | TableFlags.NotBeingSetup | TableFlags.NotLocked)
{
TypeNames = new string[] { type.Path }
};
var table = tableFilter.GetTableAsync(dataBase);
}
if (typeFlags.HasFlag(TypeFlags.IsBeingEdited) == true)
{
await type.Template.BeginEditAsync(Authentication.System);
}
return(newType);
}
return(type);
}
public static async Task <bool> GenerateRowAsync(this ITableContent content, Authentication authentication)
{
var row = await NewRandomRowAsync(content, authentication);
if (FillFields(row, authentication) == true)
{
if (RandomUtility.Within(25) == true)
{
await row.SetTagsAsync(authentication, tags.Random());
}
if (RandomUtility.Within(25) == true)
{
await row.SetIsEnabledAsync(authentication, RandomUtility.NextBoolean());
}
try
{
await content.EndNewAsync(authentication, row);
return(true);
}
catch
{
return(false);
}
}
return(false);
}
public static async Task <ITable> AddRandomChildTableAsync(this ITable table, Authentication authentication, DataBaseSettings settings)
{
var copyData = RandomUtility.NextBoolean();
var template = await table.NewTableAsync(authentication);
await template.InitializeRandomAsync(authentication);
await template.EndEditAsync(authentication);
if (template.Target is ITable[] tables)
{
foreach (var item in tables)
{
var minCount = settings.TableContext.MinRowCount;
var maxCount = settings.TableContext.MaxRowCount;
var count = RandomUtility.Next(minCount, maxCount);
await AddRandomRowsAsync(item, authentication, count);
}
return(tables.First());
}
else
{
throw new NotImplementedException();
}
}
public static bool FillFields(this CremaDataRow dataRow)
{
var changed = 0;
foreach (var item in dataRow.Table.Columns)
{
if (item.AutoIncrement == true)
{
continue;
}
if (dataRow[item.ColumnName] != DBNull.Value)
{
continue;
}
if (FillField(dataRow, item) == false)
{
return(false);
}
changed++;
}
if (RandomUtility.Within(5) == true)
{
dataRow.IsEnabled = RandomUtility.NextBoolean();
}
return(changed > 0);
}
public async Task InheritAaync(ITable table, TaskContext context)
{
var authentication = context.Authentication;
var categories = table.GetService(typeof(ITableCategoryCollection)) as ITableCategoryCollection;
var categoryPath = await categories.Dispatcher.InvokeAsync(() => categories.Random().Path);
var tableName = RandomUtility.NextIdentifier();
var copyData = RandomUtility.NextBoolean();
if (context.AllowException == false)
{
if (await VerifyAsync() == false)
{
return;
}
}
await table.InheritAsync(authentication, tableName, categoryPath, copyData);
Task <bool> VerifyAsync()
{
return(table.Dispatcher.InvokeAsync(() =>
{
if (table.Parent != null)
{
return false;
}
if (table.TemplatedParent != null)
{
return false;
}
return true;
}));
}
}
public static void TableInheritTest(this IDataBase dataBase, Authentication authentication)
{
dataBase.Dispatcher.Invoke(() =>
{
var tableContext = dataBase.TableContext;
var table = tableContext.Tables.RandomOrDefault(item => item.TemplatedParent == null && item.VerifyAccessType(authentication, AccessType.Master) && item.Parent == null);
if (table == null)
{
return;
}
var newName = string.Join("_", "Table", RandomUtility.NextIdentifier());
if (tableContext.Tables.Contains(newName) == true)
{
return;
}
var category = tableContext.Categories.RandomOrDefault(item => item.VerifyAccessType(authentication, AccessType.Master));
if (category == null)
{
return;
}
table.Inherit(authentication, newName, category.Path, RandomUtility.NextBoolean());
});
}
public static void ModifyRandomMember(this CremaDataType dataType)
{
if (RandomUtility.Within(90) == true)
{
var typeMember = dataType.Members.RandomOrDefault();
if (typeMember != null)
{
typeMember.SetRandomValue();
if (RandomUtility.Within(5) == true)
{
typeMember.IsEnabled = RandomUtility.NextBoolean();
}
}
}
else if (RandomUtility.Within(75) == true)
{
AddRandomMember(dataType);
}
else
{
var dataMember = dataType.Members.RandomOrDefault();
if (dataMember != null)
{
if (RandomUtility.Within(50) == true)
{
dataMember.Delete();
}
else
{
dataType.Members.Remove(dataMember);
}
}
}
}
public void SetAllowNull(ITableColumn column, TaskContext context)
{
column.Dispatcher.Invoke(() =>
{
var allowNull = RandomUtility.NextBoolean();
column.SetAllowNull(context.Authentication, allowNull);
});
}
public void SetIsKey(ITableColumn column, TaskContext context)
{
column.Dispatcher.Invoke(() =>
{
var isKey = RandomUtility.NextBoolean();
column.SetIsKey(context.Authentication, isKey);
});
}
public void SetIsFlag(ITypeTemplate template, TaskContext context)
{
template.Dispatcher.Invoke(() =>
{
var isFlag = RandomUtility.NextBoolean();
template.SetIsFlag(context.Authentication, isFlag);
});
}
public static ITable AddRandomDerivedTable(this ITableCategory category, Authentication authentication)
{
var tableName = RandomUtility.NextIdentifier();
var copyData = RandomUtility.NextBoolean();
var tableContext = category.GetService(typeof(ITableContext)) as ITableContext;
var table = tableContext.Tables.Random(item => item.TemplatedParent == null && item.Parent == null);
return(table.Inherit(authentication, tableName, category.Path, copyData));
}
public static void InitializeRandom(this CremaDataColumn dataColumn)
{
var dataTable = dataColumn.Table;
if (RandomUtility.Within(75) == true)
{
dataColumn.DataType = CremaDataTypeUtility.GetBaseTypes().Random();
}
else if (dataTable != null && dataTable.DataSet != null && dataTable.DataSet.Types.Any())
{
dataColumn.CremaType = dataTable.DataSet.Types.Random();
}
if (RandomUtility.Within(25) == true)
{
SetHopeType(dataColumn);
}
if (dataTable != null && dataTable.PrimaryKey.Any() == false)
{
dataColumn.IsKey = true;
}
else if (RandomUtility.Within(10) && dataColumn.DataType != typeof(bool))
{
dataColumn.IsKey = true;
dataColumn.Unique = RandomUtility.Within(75);
}
if (RandomUtility.Within(25) && dataColumn.DataType != typeof(bool))
{
var unique = RandomUtility.Within(75);
if (unique != false || dataTable == null || dataTable.PrimaryKey.Count() != 1)
{
dataColumn.Unique = unique;
}
}
if (RandomUtility.Within(25) == true)
{
dataColumn.Comment = RandomUtility.NextString();
}
if (RandomUtility.Within(25) == true)
{
dataColumn.DefaultValue = dataColumn.GetRandomValue();
}
if (CremaDataTypeUtility.CanUseAutoIncrement(dataColumn.DataType) == true && dataColumn.DefaultValue == DBNull.Value)
{
dataColumn.AutoIncrement = RandomUtility.NextBoolean();
}
if (RandomUtility.Within(5) == true)
{
dataColumn.ReadOnly = true;
}
}
public void Copy(IDataBase dataBase, Authentication authentication)
{
dataBase.Dispatcher.Invoke(() =>
{
var dataBaseName = RandomUtility.NextIdentifier();
var comment = RandomUtility.NextString();
var force = RandomUtility.NextBoolean();
dataBase.Copy(authentication, dataBaseName, comment, force);
});
}
public static async Task <ITable[]> AddRandomDerivedTableAsync(this ITableCategory category, Authentication authentication)
{
var tableCollection = category.GetService(typeof(ITableCollection)) as ITableCollection;
var tableName = RandomUtility.NextIdentifier();
var copyData = RandomUtility.NextBoolean();
var tableContext = category.GetService(typeof(ITableContext)) as ITableContext;
var table = await tableCollection.GetRandomTableAsync(item => item.TemplatedParent == null && item.Parent == null);
return(await table.InheritAsync(authentication, tableName, category.Path, copyData));
}
public async Task SetIsReadOnlyAsync(ITableColumn column, TaskContext context)
{
var authentication = context.Authentication;
if (column.IsKey == false || RandomUtility.Within(55) == true)
{
var isReadOnly = RandomUtility.NextBoolean();
await column.SetIsReadOnlyAsync(authentication, isReadOnly);
}
}
public static void CopyTable(this CremaDataSet dataSet)
{
var table = dataSet.Tables.RandomOrDefault();
if (table == null)
{
return;
}
table.Copy("Table_" + RandomUtility.NextIdentifier(), RandomUtility.NextBoolean());
}
public void Inherit(ITable table, TaskContext context)
{
table.Dispatcher.Invoke(() =>
{
var categories = table.GetService(typeof(ITableCategoryCollection)) as ITableCategoryCollection;
var categoryPath = categories.Random().Path;
var tableName = RandomUtility.NextIdentifier();
var copyData = RandomUtility.NextBoolean();
table.Inherit(context.Authentication, tableName, categoryPath, copyData);
});
}
public static async Task InitializeRandomAsync(this ITableColumn tableColumn, Authentication authentication)
{
var template = tableColumn.Template;
var table = tableColumn.Template.Target;
if (RandomUtility.Within(75) == true)
{
await tableColumn.SetDataTypeAsync(authentication, CremaDataTypeUtility.GetBaseTypeNames().Random(item => item != typeof(bool).GetTypeName()));
}
else
{
await tableColumn.SetDataTypeAsync(authentication, template.SelectableTypes.Random());
}
if (template.Count == 0)
{
await tableColumn.SetIsKeyAsync(authentication, true);
}
else if (RandomUtility.Within(10) && tableColumn.DataType != typeof(bool).GetTypeName())
{
await tableColumn.SetIsKeyAsync(authentication, true);
await tableColumn.SetIsUniqueAsync(authentication, RandomUtility.Within(75));
}
if (RandomUtility.Within(25) && tableColumn.DataType != typeof(bool).GetTypeName())
{
var unique = RandomUtility.Within(75);
if (unique != false || template.PrimaryKey.Count() != 1)
{
await tableColumn.SetIsUniqueAsync(authentication, unique);
}
}
if (RandomUtility.Within(25) == true)
{
await tableColumn.SetCommentAsync(authentication, RandomUtility.NextString());
}
if (RandomUtility.Within(25) == true)
{
await tableColumn.SetDefaultValueAsync(authentication, await tableColumn.GetRandomStringAsync());
}
if (CremaDataTypeUtility.CanUseAutoIncrement(tableColumn.DataType) == true && tableColumn.DefaultValue == null)
{
await tableColumn.SetAutoIncrementAsync(authentication, RandomUtility.NextBoolean());
}
if (RandomUtility.Within(5) == true)
{
await tableColumn.SetIsReadOnlyAsync(authentication, true);
}
}
public async Task SetIsEnabledAsync(ITableRow row, TaskContext context)
{
var authentication = context.Authentication;
if (object.Equals(context.State, System.Data.DataRowState.Detached) == true)
{
return;
}
var isEnabled = RandomUtility.NextBoolean();
await row.SetIsEnabledAsync(authentication, isEnabled);
}
public void SetIsReadOnly(ITableColumn column, TaskContext context)
{
column.Dispatcher.Invoke(() =>
{
if (column.IsKey == false || RandomUtility.Within(55) == true)
{
var isReadOnly = RandomUtility.NextBoolean();
column.SetIsReadOnly(context.Authentication, isReadOnly);
}
});
}
public static ITable AddRandomChildTable(this ITable table, Authentication authentication)
{
var copyData = RandomUtility.NextBoolean();
var template = table.NewTable(authentication);
template.InitializeRandom(authentication);
template.EndEdit(authentication);
var child = template.Table;
AddRandomRows(child, authentication, RandomUtility.Next(MinRowCount, MaxRowCount));
return(child);
}
public void SetIsEnabled(ITableRow row, TaskContext context)
{
if (object.Equals(context.State, System.Data.DataRowState.Detached) == true)
{
return;
}
row.Dispatcher.Invoke(() =>
{
var isEnabled = RandomUtility.NextBoolean();
row.SetIsEnabled(context.Authentication, isEnabled);
});
}
public async Task SetAllowNullAsync(ITableColumn column, TaskContext context)
{
var authentication = context.Authentication;
var allowNull = RandomUtility.NextBoolean();
if (context.AllowException == false)
{
if (await column.Dispatcher.InvokeAsync(() => column.IsKey == true && allowNull == true) == true)
{
return;
}
}
await column.SetAllowNullAsync(authentication, allowNull);
}
public async Task SetAutoIncrementAsync(ITableColumn column, TaskContext context)
{
var authentication = context.Authentication;
var autoIncrement = RandomUtility.NextBoolean();
if (context.AllowException == false)
{
if (autoIncrement == true && CremaDataTypeUtility.CanUseAutoIncrement(column.DataType) == false)
{
return;
}
}
await column.SetAutoIncrementAsync(authentication, autoIncrement);
}
