/// <summary>
/// 根据节点信息构造表格的头部，并返回数据绑定列
/// </summary>
/// <param name="rootNode"></param>
/// <param name="IsTrue"></param>
/// <param name="condition"></param>
/// <param name="dataColumns"></param>
/// <returns></returns>
public static string BuildTableHead(ColumnNode rootNode, IsTrueHandler IsTrue, NodeCondition condition, out List <ColumnNode> dataColumns)
{
//遍历模板树，构造一棵符合条件的树，用于生成表
TraversalTree(rootNode, IsTrue, condition);
//根据树得到头部列表
List <List <ColumnNode> > headRows = new List <List <ColumnNode> >();
dataColumns = new List <ColumnNode>();
ConvertTreeToList(rootNode, headRows, dataColumns);
StringBuilder htmlBuilder = new StringBuilder();
htmlBuilder.Append("<thead>");
for (int i = 1; i < headRows.Count; i++)
{
htmlBuilder.Append("<tr style=\"text-align:center;\">");
for (int j = 0; j < headRows[i].Count; j++)
{
//如果没有子节点，行数=总行数-当前的层级
int rowSpan = headRows[i][j].Children.Count == 0 ? headRows.Count - headRows[i][j].Level : 1;
htmlBuilder.AppendFormat("<th colspan=\"{0}\" rowspan=\"{1}\">{2}</th>", headRows[i][j].ColSpan, rowSpan, headRows[i][j].Title);
}
htmlBuilder.Append("</tr>");
}
htmlBuilder.Append("</thead>");
return(htmlBuilder.ToString());
}
public void ReplaceVertical()
{
Up.Down = this;
Down.Up = this;
ColumnNode.IncrementSize();
}
/// <summary> Puts the specified node into a properly flowing container (if it isn't already). </summary>
protected virtual LayoutNode PrepareLayout(LayoutNode currentNode, Flow flow)
{
// Ensures that the node is ready to accept a new node, and returns the parent into which the new node should be inserted
LayoutNode parent = currentNode.Parent;
switch (flow)
{
case Flow.Horizontal:
if (!(parent is RowNode))
{
RowNode rowNode = new RowNode();
rowNode.Children.Add(currentNode);
if (parent != null)
{
parent.Children.Add(rowNode);
}
return(rowNode);
}
return(parent);
default:
if (!(parent is ColumnNode))
{
ColumnNode columnNode = new ColumnNode();
columnNode.Children.Add(currentNode);
if (parent != null)
{
parent.Children.Add(columnNode);
}
return(columnNode);
}
return(parent);
}
}
void PrepareEmployeeTerritories(out TableNode tn)
{
ApplicationController.WizardControllerFactory = new WizardControllerFactory(this.GetType().Assembly, "TestApp.RelationTests+IntermediateTableWizController");
// Find Territories, map primary key, since it's not automatically detected,
// and map class
TreeNodeCollection nodes = ApplicationController.Instance.DatabaseNode.Nodes;
tn = (TableNode)FindNode(nodes, "Territories");
ColumnNode cn = (ColumnNode)FindNode(tn.Nodes, "TerritoryID");
cn.ChangePrimary(null, EventArgs.Empty);
tn.MapClass(null, EventArgs.Empty);
tn.Table.ClassName = "Territory";
// Find Employees and map class
tn = (TableNode)FindNode(nodes, "Employees");
tn.MapClass(null, EventArgs.Empty);
tn.Table.ClassName = "Employee";
tn = (TableNode)FindNode(nodes, "EmployeeTerritories");
DatabaseNode dbn = (DatabaseNode)tn.Parent;
Assertion.AssertNotNull("dbn shouldn't be null", dbn);
tn.MapIntermediateTable(null, EventArgs.Empty);
}
public void RemoveVertical()
{
Up.Down = Down;
Down.Up = Up;
ColumnNode.DecrementSize();
}
static List <Node <bool> > DancingLinks(TorodialDoubleLinkList <bool> list)
{
List <Node <bool> > solutions = new List <Node <bool> >();
ColumnNode <bool> column = list.H;
return(Search(list, column, solutions));
}
private bool AddToColumn(ColumnNode columnNode, CellNode entryNode)
{
var curr = columnNode.Down;
if (curr == null)
{
columnNode.Down = entryNode;
return(true);
}
var prevOfCurr = curr.Up;
RowType entryRow = entryNode.Value.GetRow();
RowType currRow;
int comparisonResult;
while (curr != null)
{
currRow = curr.Value.GetRow();
comparisonResult = currRow.CompareTo(entryRow);
if (comparisonResult == 0)
{
return(false);
}
else if (comparisonResult > 0)
{
var prevNode = curr.Up;
var nextNode = curr;
if (prevNode == null)//El nodo a insertar es first
{
columnNode.Down = entryNode;
entryNode.Up = null;
}
else
{
prevNode.Down = entryNode;
entryNode.Up = prevNode;
}
nextNode.Up = entryNode;
entryNode.Down = nextNode;
return(true);
}
prevOfCurr = curr;
curr = curr.Down;
}
//Como ahora curr es null tenemos que movernos de regreso a su 'prev'
curr = prevOfCurr;
currRow = curr.Value.GetRow();
comparisonResult = currRow.CompareTo(entryRow);
if (comparisonResult == 0)
{
return(false);
}
curr.Down = entryNode;
entryNode.Up = curr;
return(true);
}
static List <Node <bool> > Search(TorodialDoubleLinkList <bool> list, ColumnNode <bool> column, List <Node <bool> > solutions)
{
if (list.H.Right == list.H)
{
foreach (Node <bool> result in solutions)
{
Console.Write(result.ColumnNode.ID + "," + result.Index + " ");
}
Console.WriteLine();
return(solutions);
}
else
{
column = getNextColumn(list);
Cover(column);
Node <bool> rowNode = column;
while (rowNode.Down != column)
{
rowNode = rowNode.Down;
solutions.Add(rowNode);
Node <bool> rightNode = rowNode;
while (rightNode.Right != rowNode)
{
rightNode = rightNode.Right;
Cover(rightNode);
}
List <Node <bool> > result = Search(list, column, solutions);
if (result != null)
{
return(result);
}
solutions.Remove(rowNode);
column = rowNode.ColumnNode;
Node <bool> leftNode = rowNode;
while (leftNode.Left != rowNode)
{
leftNode = leftNode.Left;
Uncover(leftNode);
}
}
Uncover(column);
}
return(null);
}
private void MapClass(bool checkForPrimaryKey)
{
this.Table.Namespace = ApplicationController.Instance.AssemblyNode.Assembly.RootNamespace;
this.Table.MappingType = TableMappingType.MappedAsClass;
this.OnIsMappedChanged(null, EventArgs.Empty);
this.Table.PrimaryKey = string.Empty;
foreach (NDOTreeNode tn in this.Nodes)
{
ColumnNode cn = tn as ColumnNode;
if (cn != null)
{
if (!cn.IsPrimary)
{
cn.IsMapped = true;
}
else
{
this.Table.PrimaryKey = cn.Name;
if (cn.Column.Type == "System.String")
{
Assembly ass = ApplicationController.Instance.AssemblyNode.Assembly;
if (ass.MapStringsAsGuids)
{
this.Table.NdoOidType = "Guid";
}
else
{
if (ass.UseClassField)
{
cn.IsMapped = true;
}
else
{
this.Table.NdoOidType = "string";
}
}
}
}
}
}
if (checkForPrimaryKey && this.Table.PrimaryKey == string.Empty)
{
ClassGenerator.MapClassWizard.MapClassWizard wiz = new ClassGenerator.MapClassWizard.MapClassWizard(this);
DialogResult dr = wiz.ShowDialog();
if (dr == DialogResult.OK && wiz.Result != null)
{
if (wiz.Result.IsMapped)
{
wiz.Result.ChangeMapping(null, EventArgs.Empty);
}
wiz.Result.ChangePrimary(null, EventArgs.Empty);
}
}
ApplicationController.Instance.MappingChanged();
}
private void PrepareEmployeeOrder(out TableNode tn, out ColumnNode cn)
{
ApplicationController.WizardControllerFactory = new WizardControllerFactory(this.GetType().Assembly, "TestApp.RelationTests+FkWizardController");
tn = (TableNode)FindNode(ApplicationController.Instance.DatabaseNode.Nodes, "Employees");
tn.MapClass(null, EventArgs.Empty);
tn = (TableNode)FindNode(ApplicationController.Instance.DatabaseNode.Nodes, "Orders");
tn.MapClass(null, EventArgs.Empty);
cn = (ColumnNode)FindNode(tn.Nodes, "EmployeeID");
cn.ChangeMapping(null, EventArgs.Empty);
cn.MakeForeignKey(null, EventArgs.Empty);
}
private void MapClassWizard_Load(object sender, System.EventArgs e)
{
this.Text = tableNode.Text;
foreach (NDOTreeNode tn in tableNode.Nodes)
{
ColumnNode cn = tn as ColumnNode;
if (cn == null)
{
continue;
}
this.cbColumns.Items.Add(cn);
}
}
static ColumnNode <bool> getNextColumn(TorodialDoubleLinkList <bool> list)
{
ColumnNode <bool> node = list.H;
ColumnNode <bool> chosenNode = null;
while (node.Right != list.H)
{
node = (ColumnNode <bool>)node.Right;
if (chosenNode == null || node.Size < chosenNode.Size)
{
chosenNode = node;
}
}
return(chosenNode);
}
/// <summary>
/// 将树转换为列表
/// </summary>
/// <param name="rootNode"></param>
/// <param name="headRows"></param>
/// <param name="dataColumns"></param>
public static void ConvertTreeToList(ColumnNode rootNode, List <List <ColumnNode> > headRows, List <ColumnNode> dataColumns)
{
while (headRows.Count < rootNode.Level + 1)
{
headRows.Add(new List <ColumnNode>());
}
headRows[rootNode.Level].Add(rootNode);
//叶节点作为数据绑定列
if (rootNode.Children.Count == 0)
{
dataColumns.Add(rootNode);
}
//遍历子节点
foreach (ColumnNode childNode in rootNode.Children)
{
ConvertTreeToList(childNode, headRows, dataColumns);
}
}
public void MakeForeignKey(ColumnNode columnNode, ForeignKeyWizModel model)
{
FkRelation fkRelation = null;
RelationNode relationNode = null;
if (model == null)
{
fkRelation = new FkRelation(columnNode.Name);
relationNode = new RelationNode(fkRelation, columnNode.Parent);
}
else
{
fkRelation = (FkRelation)model.RelationNode.Relation;
relationNode = model.RelationNode;
}
fkRelation.OwningTable = ((TableNode)relationNode.Parent).Table.Name;
fkRelation.OwningType = ((TableNode)relationNode.Parent).Table.ClassName;
IList tableNodes = new ArrayList();
if (model == null)
{
foreach (TableNode tnode in ((DatabaseNode)columnNode.Parent.Parent).TableNodes)
{
if (tnode.Table.MappingType == TableMappingType.MappedAsClass)
{
tableNodes.Add(tnode);
}
}
model = new ForeignKeyWizModel(relationNode, tableNodes);
IWizardController controller = ApplicationController.wizardControllerFactory.Create
("ForeignKeyWizController", "ForeignKeyWiz", "Foreign Key Wizard");
//controller.FrameSize = new Size( 544, 408 );
DialogResult r = controller.Run(model);
if (r == DialogResult.OK)
{
MakeForeignKeyRelation(relationNode, columnNode, model);
}
}
else
{
MakeForeignKeyRelation(relationNode, columnNode, model);
}
}
private void DeleteColumn(ColumnNode columnNode)
{
var left = columnNode.Left;
var right = columnNode.Right;
if (left == null)//currRow es first
{
ColumnNodeHead = right;
}
else
{
left.Right = right;
}
if (right != null)
{
right.Left = left;
}
}
private void OnIsPrimaryChanged(object sender, EventArgs e)
{
ColumnNode cn = sender as ColumnNode;
if (cn == null)
{
return;
}
if (cn.IsPrimary)
{
this.Table.PrimaryKey = cn.Text;
}
if (cn.Name == this.Table.PrimaryKey)
{
if (!cn.IsPrimary)
{
this.Table.PrimaryKey = string.Empty;
}
}
}
static void Uncover(Node <bool> node)
{
ColumnNode <bool> column = node.ColumnNode;
Node <bool> verticalNode = column;
while (verticalNode.Up != column)
{
verticalNode = verticalNode.Up;
Node <bool> removeNode = verticalNode;
while (removeNode.Left != verticalNode)
{
removeNode = removeNode.Left;
removeNode.ReplaceVertical();
}
}
column.ReplaceHorizontal();
}
public Project(ProjectNode root)
{
m_Random = root.Serializer.Random;
m_Rules = new RuleCollection(m_Random);
foreach (IProjectNode node in root.Children)
{
switch (node.NodeType)
{
case ProjectNodeType.TokenSetDeclaration:
this.TokenSets.Add(new TokenSet(node, m_Random));
break;
case ProjectNodeType.RuleDeclaration:
this.Rules.Add(new Rule(node as RuleNode));
break;
case ProjectNodeType.StartingRuleDeclaration:
StartingRuleNode srn = node as StartingRuleNode;
this.StartRules.Add(srn.Name, srn.Amount);
break;
case ProjectNodeType.ColumnDeclaration:
ColumnNode cn = node as ColumnNode;
this.Columns.Add(cn.Title, cn.Expression);
break;
default:
break;
}
}
foreach (Rule r in this.Rules)
{
foreach (Whee.WordBuilder.Model.Commands.CommandBase c in r.Commands)
{
c.CheckSanity(this, root.Serializer);
}
}
}
private void MakeForeignKeyRelation(RelationNode relationNode, ColumnNode columnNode, ForeignKeyWizModel model)
{
FkRelation fkRelation = (FkRelation)relationNode.Relation;
fkRelation.RelatedTable = relationNode.RelatedTableNode.Table.Name;
fkRelation.RelatedType = relationNode.RelatedTableNode.Table.ClassName;
TableNode tn = (TableNode)columnNode.Parent;
//tn.Nodes. Remove(columnNode);
columnNode.Remove();
tn.Nodes.Add(relationNode);
relationNode.OriginalColumnNode = columnNode;
this.assemblyNode.Refresh();
if (fkRelation.RelationDirection == RelationDirection.DirectedToMe ||
fkRelation.RelationDirection == RelationDirection.Bidirectional)
{
tn = databaseNode.FindTableNode(fkRelation.RelatedTable, true);
RelationNode rn = new RelationNode(fkRelation.ForeignRelation, tn);
rn.RelatedTableNode = (TableNode)columnNode.Parent;
tn.Nodes.Add(rn);
}
}
static void Cover(Node <bool> node)
{
ColumnNode <bool> column = node.ColumnNode;
column.RemoveHorizontal();
Node <bool> verticalNode = column;
while (verticalNode.Down != column)
{
verticalNode = verticalNode.Down;
Node <bool> removeNode = verticalNode;
while (removeNode.Right != verticalNode)
{
removeNode = removeNode.Right;
removeNode.RemoveVertical();
}
}
}
/// <summary>
/// 遍历树
/// </summary>
/// <param name="rootNode"></param>
/// <param name="IsTrue"></param>
/// <param name="condition"></param>
public static void TraversalTree(ColumnNode rootNode, IsTrueHandler IsTrue, NodeCondition condition)
{
rootNode.Children = new List <object>();
foreach (XmlNode node in rootNode.CorrespondXmlNode.ChildNodes)
{
if (IsTrue(condition, node))
{
rootNode.Children.Add(
new ColumnNode
{
CorrespondXmlNode = node,
Title = node.Attributes["title"].Value,
Name = node.Attributes["name"].Value,
Level = rootNode.Level + 1
});
}
}
foreach (object node in rootNode.Children)
{
TraversalTree((ColumnNode)node, IsTrue, condition);
}
//如果只有一个子节点，则去除该节点，去除节点的子节点上移
if (rootNode.Children.Count == 1)
{
rootNode.Children = ((ColumnNode)rootNode.Children[0]).Children;
foreach (object node in rootNode.Children)
{
((ColumnNode)node).Level = rootNode.Level + 1;
TraversalTree((ColumnNode)node, IsTrue, condition);
}
}
foreach (object node in rootNode.Children)
{
rootNode.ColSpan += ((ColumnNode)node).ColSpan;
}
rootNode.ColSpan = rootNode.ColSpan == 0 ? 1 : rootNode.ColSpan;
}
private ColumnNode GetOrAddColumnNode(ColumnType entryColumn)
{
var curr = ColumnNodeHead;
if (curr == null)
{
ColumnNodeHead = new ColumnNode(entryColumn);
return(ColumnNodeHead);
}
var prevOfCurr = curr.Left;
ColumnType currValue;
int comparisonResult;
ColumnNode entryNode;
while (curr != null)
{
currValue = curr.Value;
comparisonResult = currValue.CompareTo(entryColumn);
if (comparisonResult == 0)
{
return(curr);
}
else if (comparisonResult > 0)
{
var prevNode = curr.Left;
var nextNode = curr;
entryNode = new ColumnNode(entryColumn);
if (prevNode == null)//El nodo a insertar es first
{
ColumnNodeHead = entryNode;
entryNode.Left = null;
}
else
{
prevNode.Right = entryNode;
entryNode.Left = prevNode;
}
nextNode.Left = entryNode;
entryNode.Right = nextNode;
return(entryNode);
}
prevOfCurr = curr;
curr = curr.Right;
}
//Como ahora curr es null tenemos que movernos de regreso a su 'prev'
curr = prevOfCurr;
currValue = curr.Value;
comparisonResult = currValue.CompareTo(entryColumn);
if (comparisonResult == 0)
{
return(curr);
}
entryNode = new ColumnNode(entryColumn);
curr.Right = entryNode;
entryNode.Left = curr;
return(entryNode);
}
public void MakeForeignKey(DataRelation dataRelation)
{
// The FkRelation is owned by the child table, because it holds
// the foreign key.
// Therefore the XPath has to be stored in the ForeignFkRelation.
string xpath = (string)dataRelation.ExtendedProperties["xpath"];
TableNode ownTableNode = this.databaseNode[dataRelation.ChildTable.TableName];
TableNode foreignTableNode = this.databaseNode[dataRelation.ParentTable.TableName];
ColumnNode cn = ownTableNode[dataRelation.ChildColumns[0].ColumnName];
FkRelation fkRelation = new FkRelation(cn.Text);
RelationNode relationNode = new RelationNode(fkRelation, cn.Parent);
ForeignKeyWizModel model = new ForeignKeyWizModel(relationNode, null);
fkRelation.CodingStyle = CodingStyle.ArrayList;
fkRelation.FieldName = MakeCamelCase(foreignTableNode.Text);
fkRelation.RelationDirection = RelationDirection.DirectedToMe;// Bidirectional;
relationNode.RelatedTableNode = foreignTableNode;
fkRelation.RelatedTable = dataRelation.ParentTable.TableName;
fkRelation.RelatedType = relationNode.RelatedTableNode.Table.ClassName;
fkRelation.IsComposite = false;
string singularFieldName = null;
if (xpath != null)
{
singularFieldName = MakePascalCase(xpath.Substring(xpath.LastIndexOf('/') + 1));
}
else
{
singularFieldName = MakePascalCase(ownTableNode.Text);
}
singularFieldName = singularFieldName.Substring(singularFieldName.IndexOf(':') + 1);
string foreignFieldName = MakeCamelCase(singularFieldName);
if (foreignFieldName.EndsWith("y"))
{
char c = char.ToLower(foreignFieldName[foreignFieldName.Length - 2]);
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u')
{
foreignFieldName += "s";
}
else
{
foreignFieldName = foreignFieldName.Substring(0, foreignFieldName.Length - 1) + "ies";
}
}
else if (foreignFieldName.EndsWith("s"))
{
foreignFieldName += "es";
}
else if (foreignFieldName.EndsWith("f"))
{
foreignFieldName = foreignFieldName.Substring(0, foreignFieldName.Length - 1) + "ves";
}
else
{
foreignFieldName += "s";
}
fkRelation.ForeignFieldName = foreignFieldName;
fkRelation.ForeignIsComposite = true;
fkRelation.ForeignCodingStyle = CodingStyle.ArrayList;
fkRelation.RelationName = string.Empty;
MakeForeignKey(cn, model);
fkRelation.ForeignRelation.SingularFieldName = MakePascalCase(singularFieldName);
fkRelation.ForeignRelation.XPath = xpath;
}
public bool MapIntermediateClass(TableNode tn)
{
// IntermediateClass ic = new IntermediateClass();
// IntermediateClassNode icn = new IntermediateClassNode(ic, tn);
IList tableNodes = new ArrayList();
foreach (TableNode tnode in databaseNode.TableNodes)
{
if (tn.Text == tnode.Text)
{
continue;
}
if (tnode.Table.MappingType == TableMappingType.MappedAsClass)
{
tableNodes.Add(tnode);
}
}
IntermediateClassWizardModel model = new IntermediateClassWizardModel(tn, tableNodes);
IWizardController controller = ApplicationController.wizardControllerFactory.Create
("IntermediateClassWizController", "IntClassWiz", "Intermediate Class Wizard");
//controller.FrameSize = new Size(544, 500);
model[0].RelationDirection = RelationDirection.Bidirectional;
model[1].RelationDirection = RelationDirection.Bidirectional;
DialogResult r = controller.Run(model);
if (r == DialogResult.OK)
{
DatabaseNode parent = (DatabaseNode)tn.Parent;
// Nothing to remove, because we use the original table node
// tn.Remove();
// tn.Parent.Nodes.Add(icn);
for (int i = 0; i < 2; i++)
{
ColumnNode columnNode = (ColumnNode)tn.FindNode(model[i].ForeignKeyColumnName, typeof(ColumnNode));
FkRelation fkr = new FkRelation(columnNode.Text);
IntermediateClassInfo intermClInfo = model[i];
fkr.FieldName = intermClInfo.OwnFieldName;
fkr.ForeignCodingStyle = intermClInfo.CodingStyle;
fkr.ForeignFieldName = intermClInfo.ForeignFieldName;
fkr.ForeignIsComposite = false;
fkr.IsComposite = false;
fkr.OwningTable = tn.Text;
fkr.OwningType = tn.Table.ClassName;
fkr.RelatedTable = intermClInfo.Table;
fkr.RelatedType = intermClInfo.Type;
fkr.RelationDirection = intermClInfo.RelationDirection;
fkr.RelationName = string.Empty;
//ForeignFkRelation ffkr = fkr.ForeignRelation;
RelationNode relationNode = new RelationNode(fkr, tn);
relationNode.RelatedTableNode = (TableNode)databaseNode.FindNode(intermClInfo.Table);
ForeignKeyWizModel fkwizModel = new ForeignKeyWizModel(relationNode, new ArrayList());
tn.DualKeyRelations[i] = intermClInfo.OwnFieldName;
MakeForeignKeyRelation(relationNode, columnNode, fkwizModel);
}
return(true);
}
return(false);
}
public TableNode(DataTable dt, DatabaseNode parent, string ownerName, IDbConnection conn, IProvider provider) : base(dt.TableName, parent)
{
string tableName = dt.TableName;
SetImageIndex(15); // unmapped
this.myObject = new Table(tableName, string.Empty, (string)dt.ExtendedProperties["summary"]);
this.Table.OnIsMappedChanged += new EventHandler(OnIsMappedChanged);
#if DontUseDataSets
DataTable dt = null;
if (!parent.Database.IsXmlSchema)
{
string sql;
if (ownerName != null && ownerName.Trim() != "")
{
sql = "SELECT * FROM " + provider.GetQuotedName(ownerName) + "." + provider.GetQuotedName(tableName);
}
else
{
sql = "SELECT * FROM " + provider.GetQuotedName(tableName);
}
DataSet ds = new DataSet();
IDbCommand cmd = provider.NewSqlCommand(conn);
cmd.CommandText = sql;
IDataAdapter da = provider.NewDataAdapter(cmd, null, null, null);
da.FillSchema(ds, SchemaType.Source);
dt = ds.Tables[0];
}
else
{
dt = parent.Database.DataSet.Tables[tableName];
#endif
if (parent.Database.IsXmlSchema && dt.PrimaryKey.Length == 0)
{
string pkColumnName = GeneratePkName(dt);
DataColumn pkColumn = dt.Columns.Add(pkColumnName, typeof(int));
dt.PrimaryKey = new DataColumn[] { pkColumn };
}
foreach (DataColumn column in dt.Columns)
{
bool isPrimary = false;
bool isAutoIncremented = false;
foreach (DataColumn pkColumn in dt.PrimaryKey)
{
if (pkColumn == column)
{
isPrimary = true;
isAutoIncremented = pkColumn.AutoIncrement;
}
}
ColumnNode cn = new ColumnNode(column.ColumnName, isPrimary, isAutoIncremented, column.DataType.ToString(), (string)column.ExtendedProperties["summary"], this);
if (parent.Database.IsXmlSchema && column.ExtendedProperties.Contains("schemaType"))
{
cn.UserData.Add("schemaType", "Element");
}
cn.IsPrimaryChanged += new EventHandler(OnIsPrimaryChanged);
this.Nodes.Add(cn);
}
}
public void MakeForeignKey(ColumnNode columnNode)
{
MakeForeignKey(columnNode, null);
}
private static void GenerateXmlSaveCodeForMember(CodeConstructor xmlConstructor, CodeMemberMethod saveXmlMethod, ColumnNode columnNode, CodeMemberField field)
{
bool isElement = false;
if (columnNode.UserData.ContainsKey("schemaType"))
{
isElement = columnNode.UserData["schemaType"].ToString() == "Element";
}
string setMethodName = null;
string getMethodName = null;
if (isElement)
{
setMethodName = "SetElement";
getMethodName = "GetElement";
}
else
{
setMethodName = "SetAttribute";
getMethodName = "GetAttribute";
}
Type t = Type.GetType(columnNode.Column.Type);
CodeTypeOfExpression fieldType = null;
if (t == null)
{
fieldType = new CodeTypeOfExpression(t);
}
else
{
fieldType = new CodeTypeOfExpression(columnNode.Column.Type);
}
CodePrimitiveExpression attrName = new CodePrimitiveExpression(columnNode.Name);
CodeFieldReferenceExpression thisField = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), field.Name);
/*
* this.field = (fieldType) XmlHelper.GetAttribute(xmlNode, "AttrName", typeof(fieldType));
*/
CodeAssignStatement cas = new CodeAssignStatement(thisField,
new CodeCastExpression(columnNode.Column.Type,
new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression("XmlHelper"), getMethodName,
new CodeVariableReferenceExpression("xmlNode"), attrName, fieldType)));
xmlConstructor.Statements.Add(cas);
/*
* XmlHelper.SetAttribute(newElement, "AttrName", this.field, typeof(fieldType));
*/
CodeVariableReferenceExpression xmlHelper = new CodeVariableReferenceExpression("XmlHelper");
CodeVariableReferenceExpression newElement = new CodeVariableReferenceExpression("myElement");
CodeMethodInvokeExpression setAttributeCall = new CodeMethodInvokeExpression(xmlHelper, setMethodName, newElement, attrName, thisField, fieldType);
saveXmlMethod.Statements.Add(new CodeExpressionStatement(setAttributeCall));
}
private void LoadObjects(DbObjectSearch search = null)
{
try
{
pbLoading.Visible = true;
OperationStarted?.Invoke(this, "Loading objects...");
tvwObjects.BeginUpdate();
tvwObjects.Nodes.Clear();
var schemas = _objects
.Where(obj => !string.IsNullOrEmpty(obj.Schema) && (search?.IsIncluded(obj) ?? true))
.GroupBy(obj => obj.Schema).OrderBy(grp => grp.Key);
FolderNode folderNode = null;
foreach (var schemaGrp in schemas)
{
var schemaNode = new SchemaNode(schemaGrp.Key, schemaGrp.Count());
tvwObjects.Nodes.Add(schemaNode);
var tables = schemaGrp.OfType <Table>().OrderBy(obj => obj.Name);
if (tables.Any())
{
folderNode = new FolderNode("Tables", tables.Count());
schemaNode.Nodes.Add(folderNode);
foreach (var table in tables)
{
var tableNode = new TableNode(table);
if (_aliasManager.ContainsTable(table.ToString(), out string alias))
{
tableNode.Alias = alias;
}
folderNode.Nodes.Add(tableNode);
var foreignKeys = table.GetParentForeignKeys(_objects);
tableNode.Columns.AddRange(table.Columns.Select(col =>
{
var node = new ColumnNode(col, foreignKeys, table.IdentityColumn);
if (IsUniqueMultiColumn(table, col))
{
node.NodeFont = new Font(tvwObjects.Font, FontStyle.Bold);
}
return(node);
}));
var childFKs = table.GetChildForeignKeys(_objects);
if (childFKs.Any())
{
var childFolderNode = new TreeNode($"Child Tables ({childFKs.Count()})")
{
ImageKey = "join", SelectedImageKey = "join"
};
tableNode.Nodes.Add(childFolderNode);
foreach (var childFK in childFKs)
{
var fkNode = new TableNode(childFK);
childFolderNode.Nodes.Add(fkNode);
}
}
}
folderNode.Expand();
}
var views = schemaGrp.OfType <SqlSchema.Library.Models.View>().OrderBy(obj => obj.Name);
if (views.Any())
{
folderNode = new FolderNode("Views", views.Count());
schemaNode.Nodes.Add(folderNode);
foreach (var view in views)
{
var viewNode = new ViewNode(view);
folderNode.Nodes.Add(viewNode);
}
}
var functions = schemaGrp.OfType <TableFunction>().OrderBy(obj => obj.Name);
if (functions.Any())
{
folderNode = new FolderNode("Functions", functions.Count());
schemaNode.Nodes.Add(folderNode);
foreach (var func in functions)
{
var functionNode = new FunctionNode(func);
folderNode.Nodes.Add(functionNode);
}
}
var procs = schemaGrp.OfType <Procedure>().OrderBy(obj => obj.Name);
if (procs.Any())
{
folderNode = new FolderNode("Procedures", procs.Count());
schemaNode.Nodes.Add(folderNode);
foreach (var proc in procs)
{
var procNode = new ProcedureNode(proc);
folderNode.Nodes.Add(procNode);
}
}
schemaNode.Expand();
}
}
finally
{
tvwObjects.EndUpdate();
pbLoading.Visible = false;
OperationEnded?.Invoke(this, new EventArgs());
}
}
public PropertyGenerator(ColumnNode cn)
{
this.columnNode = cn;
}
