//private static bool IsPublicResource(this ProjectItem projectItem)
//{
// var project = projectItem.ContainingProject;
// using (var reader = XmlReader.Create(project.GetFullName()))
// {
// var doc = XDocument.Load(reader);
// var ns = doc.Root.GetDefaultNamespace();
// var namespaceManager = new XmlNamespaceManager(reader.NameTable);
// namespaceManager.AddNamespace("xs", ns.NamespaceName);
// var elements = doc.Root.XPathSelectElements($"/xs:Project/xs:ItemGroup/xs:EmbeddedResource", namespaceManager);
// foreach (var element in elements)
// {
// var attr = element.Attribute(XName.Get("Include", string.Empty));
// var match = Regex.Match(attr.Value, "(.+)[.]([^.]+)([.]resx)$");
// if (match.Success == true)
// {
// //this.CultureInfo = CultureInfo.GetCultureInfo(match.Groups[2].Value);
// //this.Name = match.Groups[1].Value + match.Groups[3].Value;
// //this.FileName = attr.Value;
// }
// else
// {
// //this.Name = attr.Value;
// //this.FileName = attr.Value;
// }
// var name = attr.Value.Replace(Path.DirectorySeparatorChar, PathUtility.SeparatorChar);
// if (name != projectItem.GetLocalPath())
// continue;
// var e1 = element.XPathSelectElement("./xs:Generator", namespaceManager);
// if (e1 != null)
// {
// return e1.Value == "PublicResXFileCodeGenerator";
// }
// }
// }
// return false;
//}
private static CremaDataTable FindTable(ProjectItem projectItem, CremaDataTable projectInfoTable)
{
var project = projectItem.ContainingProject;
var projectPath = project.GetLocalPath();
var projectItemPath = projectItem.GetLocalPathWithoutCultureInfo();
var dataSet = projectInfoTable.DataSet;
foreach (var item in projectInfoTable.Rows)
{
if (item["ProjectPath"] is string text && text == projectPath)
{
if (GetExportInfo(item) is CremaDataRow exportInfoRow)
{
return(dataSet.Tables[exportInfoRow["TableName"] as string]);
}
}
}
return(null);
CremaDataRow GetExportInfo(CremaDataRow dataRow)
{
foreach (var item in dataRow.GetChildRows("ExportInfo"))
{
if (item["FileName"] is string text && text == projectItemPath)
{
return(item);
}
}
return(null);
}
}
public TableItemViewModel(CremaDataTable dataTable)
{
this.dataTable = dataTable;
this.dataTable.ExtendedProperties[DataSetProperties.IsBeingEditedKey] = true;
this.isLoaded = true;
this.tableInfo = dataTable.TableInfo;
}
public void Add()
{
var dataTable = new CremaDataTable();
var dataColumn = dataTable.Columns.Add();
Assert.AreEqual(1, dataTable.Columns.Count);
}
public static bool ChangeRow(this CremaDataTable dataTable)
{
var dataRow = dataTable.Rows.RandomOrDefault();
if (dataRow == null)
{
return(false);
}
foreach (var item in dataTable.Columns)
{
if (RandomUtility.Within(25) == false)
{
continue;
}
try
{
dataRow.SetField(item.ColumnName, GetRandomValue(item));
}
catch
{
}
}
return(true);
}
private void WriteKeys(XmlSchema schema, XmlSchemaElement element, CremaDataTable dataTable)
{
if (dataTable.PrimaryKey.Any() == false)
{
return;
}
var key = new XmlSchemaKey()
{
Name = dataTable.KeyTypeName,
Selector = new XmlSchemaXPath()
};
key.Selector.XPath = dataTable.GetSelectorXPath(CremaSchema.TableTypePrefix, schema.TargetNamespace);
foreach (var item in dataTable.PrimaryKey)
{
var field = new XmlSchemaXPath()
{
XPath = CremaSchema.TableTypePrefix + ":" + item.ColumnName
};
key.Fields.Add(field);
}
element.Constraints.Add(key);
}
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 static void GenerateColumns(this CremaDataTable dataTable, int tryCount)
{
for (int i = 0; i < tryCount; i++)
{
CreateColumn(dataTable);
}
}
public void RenameChildFail1()
{
var dataTable = new CremaDataTable("table1");
var childTable = dataTable.Childs.Add("child1");
InvokeFail(() => childTable.TableName = "table1");
}
public static void View(CremaDataTable dataTable, TextWriter writer)
{
var columns = GetColumns();
var tableDataBuilder = new TableDataBuilder(columns);
var count = 0;
var rows = ViewProperties.Sort == string.Empty ? dataTable.Select(ViewProperties.Expression) : dataTable.Select(ViewProperties.Expression, ViewProperties.Sort);
foreach (var item in rows)
{
var items = columns.Select(i => $"{item[i]}").ToArray();
if (ViewProperties.Limit >= 0 && ViewProperties.Limit <= count)
{
break;
}
tableDataBuilder.Add(items);
count++;
}
writer.WriteLine();
writer.PrintTableData(tableDataBuilder.Data, true);
writer.WriteLine();
string[] GetColumns()
{
var query = from item in dataTable.Columns
where item.IsKey || StringUtility.GlobMany(item.ColumnName, ViewProperties.Columns)
select item.ColumnName;
if (ColumnLimit <= 0)
{
return(query.ToArray());
}
return(query.Take(ColumnLimit).ToArray());
}
}
public static void AddRandomAttributes(this CremaDataTable dataTable, int count)
{
for (var i = 0; i < count; i++)
{
AddRandomAttribute(dataTable);
}
}
public static CremaDataColumn AddRandomColumn(this CremaDataTable dataTable, string columnName)
{
var column = dataTable.Columns.Add(columnName);
column.InitializeRandom();
return(column);
}
public static CremaAttribute AddRandomAttribute(this CremaDataTable dataTable)
{
var attribute = dataTable.Attributes.Add();
attribute.InitializeRandom();
return(attribute);
}
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 static void View(CremaDataTable dataTable, TextWriter writer)
{
throw new NotImplementedException("dotnet");
// var columns = GetColumns();
// var tableDataBuilder = new TableDataBuilder(columns);
// var count = 0;
// var rows = ViewProperties.Sort == string.Empty ? dataTable.Select(ViewProperties.Expression) : dataTable.Select(ViewProperties.Expression, ViewProperties.Sort);
// foreach (var item in rows)
// {
// var items = columns.Select(i => $"{item[i]}").ToArray();
// if (ViewProperties.Limit >= 0 && ViewProperties.Limit <= count)
// break;
// tableDataBuilder.Add(items);
// count++;
// }
// writer.PrintTableData(tableDataBuilder.Data, true);
// writer.WriteLine();
// string[] GetColumns()
// {
// var query = from item in dataTable.Columns
// where item.IsKey || StringUtility.GlobMany(item.ColumnName, ViewProperties.Columns)
// select item.ColumnName;
// if (ColumnLimit <= 0)
// return query.ToArray();
// return query.Take(ColumnLimit).ToArray();
// }
}
internal static void FillRows(CremaDataTable diffTable1, CremaDataTable diffTable2, CremaDataTable dataTable1, CremaDataTable dataTable2)
{
if (dataTable1 != null)
{
AddRows(dataTable1, diffTable1);
}
if (dataTable2 != null)
{
AddRows(dataTable2, diffTable2);
}
void AddRows(CremaDataTable sourceTable, CremaDataTable destTable)
{
foreach (var item in sourceTable.Rows)
{
AddRow(item);
}
void AddRow(CremaDataRow sourceRow)
{
var dataRow = destTable.NewRow();
foreach (var c in sourceTable.Columns)
{
dataRow[c.ColumnName] = sourceRow[c];
}
destTable.Rows.Add(dataRow);
}
}
}
private static void Import(CremaDataTable dataTable, SerializationTable serializedTable)
{
dataTable.Tags = serializedTable.Tags;
dataTable.CategoryPath = serializedTable.CategoryPath;
dataTable.TableName = serializedTable.TableName;
dataTable.Comment = serializedTable.Comment;
var columns = serializedTable.Columns.Where(item => item.Name != CremaSchema.__RelationID__ && item.Name != CremaSchema.__ParentID__);
foreach (var item in columns)
{
var dataColumn = dataTable.Columns.Add(item.Name);
Import(dataColumn, item);
}
foreach (var item in columns)
{
var dataColumn = dataTable.Columns[item.Name];
dataColumn.IsKey = item.IsKey;
}
foreach (var item in columns)
{
var dataColumn = dataTable.Columns[item.Name];
dataColumn.Unique = item.IsUnique;
}
dataTable.AcceptChanges();
}
internal static bool InitializeRows(CremaDataTable diffTable1, CremaDataTable diffTable2, CremaDataTable dataTable1, CremaDataTable dataTable2)
{
var differ = new Differ();
var inlineBuilder = new SideBySideDiffBuilder(differ);
var rowText1 = dataTable1 == null ? string.Empty : GetString(dataTable1.Rows);
var rowText2 = dataTable2 == null ? string.Empty : GetString(dataTable2.Rows);
var rowDiff = inlineBuilder.BuildDiffModel(rowText1, rowText2);
var types1 = rowDiff.OldText.Lines.Select(item => item.Type).ToArray();
var types2 = rowDiff.NewText.Lines.Select(item => item.Type).ToArray();
foreach (var item in diffTable1.Childs)
{
item.Rows.Clear();
}
diffTable1.Rows.Clear();
foreach (var item in diffTable2.Childs)
{
item.Rows.Clear();
}
diffTable2.Rows.Clear();
diffTable1.BeginLoad();
diffTable2.BeginLoad();
FillRows(diffTable1, dataTable1, rowDiff.OldText.Lines);
FillRows(diffTable2, dataTable2, rowDiff.NewText.Lines);
diffTable1.EndLoad();
diffTable2.EndLoad();
return(true);
}
public static void CreateStandardChild(CremaDataTable table)
{
CreateStandardChild(table, "child_all", TagInfoUtility.All);
CreateStandardChild(table, "child_server", TagInfoUtility.Server);
CreateStandardChild(table, "child_client", TagInfoUtility.Client);
CreateStandardChild(table, "child_unused", TagInfoUtility.Unused);
}
private void AdjustColumns(CremaDataTable dataTable, IXLWorksheet worksheet)
{
var index = 1;
if (this.settings.OmitAttribute == false)
{
worksheet.Column(index++).AdjustToContents();
worksheet.Column(index++).AdjustToContents();
}
foreach (var item in this.GetSortedColumn(dataTable))
{
var column = worksheet.Column(index++);
column.AdjustToContents();
}
if (dataTable.Parent != null)
{
var column = worksheet.Column(index++);
column.AdjustToContents();
}
if (this.settings.OmitSignatureDate == false)
{
worksheet.Column(index++).AdjustToContents();
worksheet.Column(index++).AdjustToContents();
worksheet.Column(index++).AdjustToContents();
worksheet.Column(index++).AdjustToContents();
}
}
public static void FillStandardTable(CremaDataTable table)
{
FillStandardTable(table, TagInfoUtility.All);
FillStandardTable(table, TagInfoUtility.Server);
FillStandardTable(table, TagInfoUtility.Client);
FillStandardTable(table, TagInfoUtility.Unused);
}
public static bool CreateRow(this CremaDataTable dataTable)
{
var parent = dataTable.Parent;
CremaDataRow parentRow = null;
if (parent != null)
{
if (parent.Rows.Any() == true)
{
parentRow = parent.Rows.Random();
}
else
{
return(false);
}
}
var dataRow = dataTable.NewRow(parentRow);
foreach (var item in dataTable.Columns)
{
dataRow.SetField(item.ColumnName, GetRandomValue(item));
}
try
{
dataTable.Rows.Add(dataRow);
}
catch
{
return(false);
}
return(true);
}
public void ChangeDataType_Fail()
{
var table = new CremaDataTable();
try
{
table.Columns.Add(RandomUtility.NextIdentifier(), typeof(AttributeTargets));
Assert.Inconclusive();
}
catch
{
}
Assert.IsFalse(table.Columns.Any());
var column = table.Columns.Add(RandomUtility.NextIdentifier());
try
{
column.DataType = typeof(AttributeTargets);
Assert.Inconclusive();
}
catch
{
}
Assert.IsNull(column.CremaType);
}
private void WriteUniques(XmlSchema schema, XmlSchemaElement element, CremaDataTable dataTable)
{
foreach (var item in dataTable.Columns)
{
if (item.Unique == false)
{
continue;
}
if (item.IsKey == true && dataTable.PrimaryKey.Length == 1)
{
continue;
}
var unique = new XmlSchemaUnique()
{
Name = dataTable.Name + "." + item.ColumnName + "." + "Unique",
Selector = new XmlSchemaXPath()
};
unique.Selector.XPath = dataTable.GetSelectorXPath(CremaSchema.TableTypePrefix, schema.TargetNamespace);
var field = new XmlSchemaXPath()
{
XPath = CremaSchema.TableTypePrefix + ":" + item.ColumnName
};
unique.Fields.Add(field);
element.Constraints.Add(unique);
}
}
public void ChangeCremaType_Fail()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var table = new CremaDataTable();
try
{
table.Columns.Add(RandomUtility.NextIdentifier(), dataSet.Types.Random());
Assert.Inconclusive();
}
catch
{
}
Assert.IsFalse(table.Columns.Any());
var column = table.Columns.Add(RandomUtility.NextIdentifier());
try
{
column.CremaType = dataSet.Types.Random();
Assert.Inconclusive();
}
catch
{
}
Assert.IsNull(column.CremaType);
}
internal DiffTemplate(CremaDataTable diffTable1, CremaDataTable diffTable2, CremaDataTable dataTable1, CremaDataTable dataTable2)
{
this.diffTable1 = diffTable1.CloneTo(new CremaDataSet());
this.diffTable2 = diffTable2.CloneTo(new CremaDataSet());
foreach (var item in diffTable1.Columns)
{
var column = this.diffTable1.Columns[item.ColumnName];
DiffUtility.SetDiffState(column, DiffUtility.GetDiffState(item));
}
foreach (var item in diffTable2.Columns)
{
var column = this.diffTable2.Columns[item.ColumnName];
DiffUtility.SetDiffState(column, DiffUtility.GetDiffState(item));
}
this.dataTable1 = dataTable1;
this.dataTable2 = dataTable2;
this.diffSource1 = Create(this.diffTable1);
this.diffSource2 = Create(this.diffTable2);
this.diffSource1.ExtendedProperties[typeof(DiffTemplate)] = this;
this.diffSource2.ExtendedProperties[typeof(DiffTemplate)] = this;
this.dummy1 = this.diffSource1.TableName.StartsWith(DiffUtility.DiffDummyKey);
this.dummy2 = this.diffSource2.TableName.StartsWith(DiffUtility.DiffDummyKey);
this.AttachEventHandler(this.diffSource1, diffTable1);
this.AttachEventHandler(this.diffSource2, diffTable2);
}
public void Remove_Fail1()
{
var dataTable = new CremaDataTable();
var dataColumn = null as CremaDataColumn;
dataTable.Columns.Remove(dataColumn);
}
public void AddColumnByNameAndType()
{
var dataTable = new CremaDataTable();
var dataColumn = dataTable.Columns.Add("Column1", typeof(string));
Assert.AreEqual(1, dataTable.Columns.Count);
}
internal static void SyncColumns(CremaDataTable diffTable1, CremaDataTable diffTable2, CremaDataTable dataTable1, CremaDataTable dataTable2)
{
var inlineBuilder = new SideBySideDiffBuilder(new Differ());
var columnText1 = dataTable1 == null ? string.Empty : GetString(dataTable1.Columns);
var columnText2 = dataTable2 == null ? string.Empty : GetString(dataTable2.Columns);
var columnDiff = inlineBuilder.BuildDiffModel(columnText1, columnText2);
diffTable1.Clear();
diffTable2.Clear();
diffTable1.Columns.Clear();
diffTable2.Columns.Clear();
FillColumns(diffTable1, dataTable1, columnDiff.OldText.Lines);
FillColumns(diffTable2, dataTable2, columnDiff.NewText.Lines);
if (dataTable1 == null)
{
foreach (var item in diffTable1.Columns)
{
DiffUtility.SetDiffState(item, DiffState.Imaginary);
}
}
if (dataTable2 == null)
{
foreach (var item in diffTable2.Columns)
{
DiffUtility.SetDiffState(item, DiffState.Imaginary);
}
}
}
public Table AddNew(Authentication authentication, TableInfo tableInfo)
{
this.DataBase.ValidateBeginInDataBase(authentication);
this.Container.InvokeChildTableCreate(authentication, this);
var tableName = tableInfo.TableName;
var childTable = this.Container.AddNew(authentication, tableInfo.Name, tableInfo.CategoryPath);
childTable.Initialize(tableInfo);
foreach (var item in this.DerivedTables)
{
var derivedInfo = tableInfo;
derivedInfo.Name = CremaDataTable.GenerateName(item.Name, tableName);
derivedInfo.CategoryPath = item.Category.Path;
derivedInfo.TemplatedParent = childTable.Name;
var derivedChild = this.Container.AddNew(authentication, derivedInfo.Name, derivedInfo.CategoryPath);
derivedChild.TemplatedParent = childTable;
derivedChild.Initialize(derivedInfo);
}
var items = EnumerableUtility.Friends(childTable, childTable.DerivedTables).ToArray();
this.Container.InvokeTablesCreatedEvent(authentication, items);
return(childTable);
}
private static void WriteDesigner(this ProjectItem projectItem, CremaDataTable dataTable, bool isPublic)
{
var project = projectItem.ContainingProject;
var projectPath = Path.GetDirectoryName(project.GetFullName());
var designerFileName = Path.Combine(projectPath, projectItem.GetCustomToolOutput());
var resxFileName = projectItem.GetFullPath();
var ss = StringUtility.SplitPath(Path.GetDirectoryName(projectItem.GetLocalPath()));
var codeNamespace = $"{project.GetRootNamespace()}.{string.Join(".", ss)}";
var baseName = Path.GetFileNameWithoutExtension(projectItem.GetLocalPath());
using (var sw = new StreamWriter(designerFileName))
{
var errors = null as string[];
var provider = new CSharpCodeProvider();
var code = StronglyTypedResourceBuilder.Create(resxFileName, baseName, codeNamespace, provider, isPublic == false, out errors);
if (errors.Length > 0)
{
foreach (var error in errors)
{
Console.WriteLine(error);
}
return;
}
provider.GenerateCodeFromCompileUnit(code, sw, new CodeGeneratorOptions());
Console.WriteLine(designerFileName);
}
}
