/// <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; }