public JsonResult retuTreeJson()
{
Extjs4_0.Models.Ext_Tree extTree = new Extjs4_0.Models.Ext_Tree();
List <treeNode> listNode = new List <treeNode>();
int nodeID = -99;
if (Request["node"] != null && int.TryParse(Request["node"].ToString(), out nodeID))
{
for (int i = 0; i < nodeID; i++)
{
treeNode node = new treeNode();
node.id = (i + 1) * 20;
node.leaf = i % 2 == 0 ? true : false;
node.loaded = true;
node.name = Guid.NewGuid().ToString();
listNode.Add(node);
}
}
else
{
for (int i = 0; i < 10; i++)
{
treeNode node = new treeNode();
node.id = i + 1;
node.leaf = i % 2 == 0 ? true : false;
node.name = Guid.NewGuid().ToString();
node.loaded = true;
listNode.Add(node);
}
}
extTree.children = listNode;
extTree.success = true;
return(Json(extTree, JsonRequestBehavior.AllowGet));
}
//==================================================================================
public void complete_tree(treeNode child)
{
client clt = DB.client.Where(c => c.id == child.id).Single();
if (clt.my_childs != null)
{
string myChildsIds = clt.my_childs;
List <string> myChildsIds_List = myChildsIds.Split(',').ToList();
foreach (string childId in myChildsIds_List)
{
int child_id = Int32.Parse(childId);
treeNode node = new treeNode();
node.id = child_id;
client ct = DB.client.Where(c => c.id == child_id).Single();
node.name = ct.name;
node.Numfollow = (int)ct.num_followers;
child.childs.Add(node); //add child to the current node
complete_tree(node); //recursion
}
}
}
private void GetTreeNodeList(List <BaseMenu> _menuList, int PId, treeNode _node)
{
List <BaseMenu> menus = _menuList.FindAll(x => x.PMenuId == PId).OrderBy(x => x.SortId).ToList();
if (menus.Count > 0)
{
_node.children = new List <treeNode>();
for (int i = 0; i < menus.Count; i++)
{
treeNode nodemenu = new treeNode(menus[i].MenuId, menus[i].Name);
//nodemenu.check = menugroup.FindIndex(x => x.MenuId == menus[i].MenuId) >= 0 ? true : false;
GetTreeNodeList(_menuList, menus[i].MenuId, nodemenu);
nodemenu.attributes = new Dictionary <string, object>();
if (string.IsNullOrEmpty(menus[i].FunName) && string.IsNullOrEmpty(menus[i].FunWcfName) && string.IsNullOrEmpty(menus[i].UrlName))
{
nodemenu.attributes.Add("isclass", true);
}
else
{
nodemenu.attributes.Add("ismenu", true);
}
nodemenu.attributes.Add("moduleid", menus[i].ModuleId);
_node.children.Add(nodemenu);
}
}
}
private treeNode statement()
{
treeNode temp_statement_node = new treeNode();
switch (current_token.token_Type)
{
case tokenType.If:
temp_statement_node = if_stmt();
break;
case tokenType.Repeat:
temp_statement_node = repeat_stmt();
break;
case tokenType.ID:
temp_statement_node = assign_stmt();
break;
case tokenType.Read:
temp_statement_node = read_stmt();
break;
case tokenType.Write:
temp_statement_node = write_stmt();
break;
default:
//error("");
break;
}
return(temp_statement_node);
}
public treeNode Parse()
{
treeNode TreeHead = new treeNode();
current_token = tokens[0];
counter = 0;
TreeHead = stmt_sequence();
return(TreeHead);
}
public void GetMenuTree()
{
try
{
List <BaseModule> moduleList = NewObject <BaseModule>().getlist <BaseModule>();
List <BaseMenu> menuList = NewObject <BaseMenu>().getlist <BaseMenu>();
//AbstractModule module = NewObject<AbstractModule>();
//List<AbstractModule> moduleList = module.GetModuleList();
//AbstractMenu menu = NewObject<AbstractMenu>();
//List<AbstractMenu> menuList = menu.GetMenuList();
List <treeNode> tree = new List <treeNode>();
for (int i = 0; i < moduleList.Count; i++)
{
treeNode node = new treeNode(moduleList[i].ModuleId, moduleList[i].Name);
node.state = "open";
node.attributes = new Dictionary <string, object>();
node.attributes.Add("ismodule", true);
node.attributes.Add("moduleid", moduleList[i].ModuleId);
List <BaseMenu> menus = menuList.FindAll(x => (x.ModuleId == moduleList[i].ModuleId && x.PMenuId == -1)).OrderBy(x => x.SortId).ToList();
if (menus.Count > 0)
{
node.children = new List <treeNode>();
for (int j = 0; j < menus.Count; j++)
{
treeNode nodemenu = new treeNode(menus[j].MenuId, menus[j].Name);
//nodemenu.check = menugroup.FindIndex(x => x.MenuId == menus[j].MenuId) >= 0 ? true : false;
GetTreeNodeList(menuList, menus[j].MenuId, nodemenu);
nodemenu.attributes = new Dictionary <string, object>();
if (string.IsNullOrEmpty(menus[j].FunName) && string.IsNullOrEmpty(menus[j].FunWcfName) && string.IsNullOrEmpty(menus[j].UrlName))
{
nodemenu.attributes.Add("isclass", true);
}
else
{
nodemenu.attributes.Add("ismenu", true);
}
nodemenu.attributes.Add("moduleid", menus[j].ModuleId);
node.children.Add(nodemenu);
}
}
tree.Add(node);
}
JsonResult = ToTreeJson(tree);
}
catch (Exception ex)
{
JsonResult = ex.Message;
}
}
private treeNode write_stmt()
{
treeNode temp_write_stmt = new treeNode();
temp_write_stmt.nodekind = nodeKind.Stmt;
temp_write_stmt.stmtkind = stmtKind.Write;
match(tokenType.Write);
temp_write_stmt.child[0] = exp();
return(temp_write_stmt);
}
private treeNode read_stmt()
{
treeNode temp_read_stmt = new treeNode();
temp_read_stmt.nodekind = nodeKind.Stmt;
temp_read_stmt.stmtkind = stmtKind.Read;
match(tokenType.Read);
match(tokenType.ID);
temp_read_stmt.name = previousToken().token_Name;
return(temp_read_stmt);
}
public void GetGroupMenu()
{
try
{
int groupid = Convert.ToInt32(ParamsData["groupId"]);
List <BaseModule> moduleList = NewObject <BaseModule>().getlist <BaseModule>();
List <BaseMenu> menuList = NewObject <BaseMenu>().getlist <BaseMenu>();
Menu menu = NewObject <Menu>();
List <BaseMenu> _menugroup = menu.GetGroupMenuList(groupid);
List <BaseMenu> menugroup = new List <BaseMenu>();
for (int i = 0; i < _menugroup.Count; i++)
{
if (menuList.FindIndex(x => x.PMenuId == _menugroup[i].MenuId) == -1)
{
menugroup.Add(_menugroup[i]);
}
}
List <treeNode> tree = new List <treeNode>();
for (int i = 0; i < moduleList.Count; i++)
{
treeNode node = new treeNode(moduleList[i].ModuleId, moduleList[i].Name);
node.state = "open";
node.attributes = new Dictionary <string, object>();
node.attributes.Add("ismodule", true);
List <BaseMenu> menus = menuList.FindAll(x => (x.ModuleId == moduleList[i].ModuleId && x.PMenuId == -1)).OrderBy(x => x.SortId).ToList();
if (menus.Count > 0)
{
node.children = new List <treeNode>();
for (int j = 0; j < menus.Count; j++)
{
treeNode nodemenu = new treeNode(menus[j].MenuId, menus[j].Name);
nodemenu.check = menugroup.FindIndex(x => x.MenuId == menus[j].MenuId) >= 0 ? true : false;
GetTreeNodeList(menuList, menugroup, menus[j].MenuId, nodemenu);
node.children.Add(nodemenu);
}
}
tree.Add(node);
}
JsonResult = ToTreeJson(tree);
}
catch (Exception ex)
{
JsonResult = ex.Message;
}
}
private treeNode assign_stmt()
{
treeNode temp_assign_stmt = new treeNode();
temp_assign_stmt.nodekind = nodeKind.Stmt;
temp_assign_stmt.stmtkind = stmtKind.Assign;
match(tokenType.ID);
temp_assign_stmt.name = previousToken().token_Name;
match(tokenType.Assign);
temp_assign_stmt.child[0] = exp();
return(temp_assign_stmt);
}
private treeNode repeat_stmt()
{
treeNode temp_repeat_stmt = new treeNode();
temp_repeat_stmt.nodekind = nodeKind.Stmt;
temp_repeat_stmt.stmtkind = stmtKind.Repeat;
match(tokenType.Repeat);
temp_repeat_stmt.child[0] = stmt_sequence();
match(tokenType.Until);
temp_repeat_stmt.child[1] = exp();
return(temp_repeat_stmt);
}
private void find(treeNode[] nodes,bool[] asked, int cur)
{
int pa = nodes[cur].ParentIndex;
if (asked[pa])
{
}
else
{
find(nodes, asked, pa);
}
nodes[cur].Pro = nodes[cur].ProDe * nodes[pa].Pro + nodes[cur].ProNoDe * nodes[pa].ProNo;
nodes[cur].ProNo = 1 - nodes[cur].Pro;
asked[cur] = true;
}
private void GetTreeNodeList(List <BaseDeptLayer> _layerlist, BaseDeptLayer _layer, treeNode _node)
{
List <BaseDeptLayer> list = _layerlist.FindAll(x => x.PId == _layer.LayerId);
if (list.Count > 0)
{
_node.children = new List <treeNode>();
for (int i = 0; i < list.Count; i++)
{
treeNode node = new treeNode(list[i].LayerId, list[i].Name);
GetTreeNodeList(_layerlist, list[i], node);
_node.children.Add(node);
}
}
}
private void GetTreeNodeList(List <BaseMenu> _menuList, List <BaseMenu> menugroup, int PId, treeNode _node)
{
List <BaseMenu> menus = _menuList.FindAll(x => x.PMenuId == PId).OrderBy(x => x.SortId).ToList();
if (menus.Count > 0)
{
_node.children = new List <treeNode>();
for (int i = 0; i < menus.Count; i++)
{
treeNode nodemenu = new treeNode(menus[i].MenuId, menus[i].Name);
nodemenu.check = menugroup.FindIndex(x => x.MenuId == menus[i].MenuId) >= 0 ? true : false;
GetTreeNodeList(_menuList, menugroup, menus[i].MenuId, nodemenu);
_node.children.Add(nodemenu);
}
}
}
public void GetDeptLayers()
{
List <BaseDeptLayer> layerlist = NewObject <BaseDeptLayer>().getlist <BaseDeptLayer>();
List <BaseDeptLayer> root = layerlist.FindAll(x => x.PId == 0);
List <treeNode> tree = new List <treeNode>();
for (int i = 0; i < root.Count; i++)
{
treeNode node = new treeNode(root[i].LayerId, root[i].Name);
GetTreeNodeList(layerlist, root[i], node);
tree.Add(node);
}
JsonResult = ToTreeJson(tree);
}
public int[] getOdds(string[] tree, int lowerBound, int upperBound)
{
int n = tree.Length;
treeNode[] nodes = new treeNode[n];
bool[] asked = new bool[n];
for (int i = 0; i < n; ++i)
{
nodes[i] = new treeNode();
nodes[i].Index = i;
asked[i] = false;
}
asked[0] = true;
nodes[0].ParentIndex = -1;
nodes[0].Pro = int.Parse(tree[0]) / 100.0;
nodes[0].ProNo = 1 - nodes[0].Pro;
for (int i = 1; i < n; ++i)
{
string s = tree[i];
string[] ss = s.Split(new char[] { ' ' });
int a = int.Parse(ss[0]);
int b = int.Parse(ss[1]);
int c = int.Parse(ss[2]);
nodes[i].ParentIndex = a;
nodes[i].ProDe = b / 100.0;
nodes[i].ProNoDe = c / 100.0;
}
for (int i = 1; i < n; ++i)
{
if (!asked[i])
{
find(nodes, asked, i);
}
}
List<int> result = new List<int>();
for (int i = 0; i < n; ++i)
{
if (lowerBound <= nodes[i].Pro*100 && nodes[i].Pro*100 <= upperBound)
{
result.Add(i);
}
}
return result.ToArray();
}
public treeNode()
{
child = new treeNode[maxChilds];
sibling = null;
lineno = null;
nodekind = null;
stmtkind = null;
expkind = null;
tokentype = null;
val = null;
name = "";
exptype = null;
}
public static HtmlString CreateChildrenList(this IHtmlHelper html, treeNode node)
{
if (node.childrens.Count == 0)
{
return(new HtmlString(" "));
}
string result = "<ul>";
foreach (var item in node.childrens)
{
result += $"<li>{item.personNode.Name}";
result += CreateChildrenList(html, item);
result += $"</li>";
}
result += "</ul>";
return(new HtmlString(result));
}
public treeNode stmt_sequence()
{
treeNode temp_stmt_node = new treeNode(), new_temp_stmt_node = new treeNode();
treeNode start = new treeNode();
temp_stmt_node = statement();
start = temp_stmt_node;
while (current_token.token_Type == tokenType.SemiColon)
{
match(tokenType.SemiColon);
new_temp_stmt_node = statement();
temp_stmt_node.sibling = new_temp_stmt_node;
temp_stmt_node = new_temp_stmt_node;
}
return(start);
}
/// <summary>
/// Inserts a new node to the tree.
/// </summary>
/// <param name="data">new node to insert afters.</param>
public void addNode(T[] data)
{
treeNode <T>[] temp = new treeNode <T> [data.Length];
for (int i = 0; i < data.Length; ++i)
{
temp[i] = new treeNode <T>(data[i]);
}
for (int i = 0; i < data.Length / 2; ++i)
{
try {
temp[i].left = temp[2 * i + 1];
temp[i].right = temp[2 * i + 2];
}
catch (IndexOutOfRangeException) {
break;
}
}
head = temp[0];
}
private treeNode if_stmt()
{
treeNode temp_if_stmt = new treeNode();
temp_if_stmt.nodekind = nodeKind.Stmt;
temp_if_stmt.stmtkind = stmtKind.If;
match(tokenType.If);
temp_if_stmt.child[0] = exp();
match(tokenType.Then);
temp_if_stmt.child[1] = stmt_sequence();
if (current_token.token_Type == tokenType.Else)
{
match(tokenType.Else);
temp_if_stmt.child[2] = stmt_sequence();
}
match(tokenType.End);
return(temp_if_stmt);
}
private treeNode term()
{
treeNode temp_term = new treeNode(), new_temp_term = new treeNode();
temp_term = factor();
while (current_token.token_Type == tokenType.Times)
{
new_temp_term.nodekind = nodeKind.Exp;
new_temp_term.expkind = expKind.Op;
new_temp_term.exptype = expType.Integer;
new_temp_term.tokentype = current_token;
match(current_token.token_Type);
new_temp_term.child[0] = temp_term;
new_temp_term.child[1] = factor();
temp_term = new_temp_term;
}
return(temp_term);
}
private treeNode simple_exp()
{
treeNode temp_simple_exp = new treeNode(), new_temp_simple_exp = new treeNode();
temp_simple_exp = term();
while (current_token.token_Type == tokenType.Plus || current_token.token_Type == tokenType.Minus)
{
new_temp_simple_exp.nodekind = nodeKind.Exp;
new_temp_simple_exp.expkind = expKind.Op;
new_temp_simple_exp.exptype = expType.Integer;
new_temp_simple_exp.tokentype = current_token;
match(current_token.token_Type);
new_temp_simple_exp.child[0] = temp_simple_exp;
new_temp_simple_exp.child[1] = term();
temp_simple_exp = new_temp_simple_exp;
}
return(temp_simple_exp);
}
private treeNode exp()
{
treeNode temp_exp = new treeNode(), new_temp_exp = new treeNode();
temp_exp = simple_exp();
if (current_token.token_Type == tokenType.LessThan || current_token.token_Type == tokenType.Equal)
{
new_temp_exp.nodekind = nodeKind.Exp;
new_temp_exp.expkind = expKind.Op;
new_temp_exp.exptype = expType.Boolean;
new_temp_exp.tokentype = current_token;
match(current_token.token_Type);
new_temp_exp.child[0] = temp_exp;
new_temp_exp.child[1] = simple_exp();
temp_exp = new_temp_exp;
}
return(temp_exp);
}
public async Task <IActionResult> Index()
{
Dictionary <long, List <PersonModel> > data = db.Persons.ToList()
.OrderBy(r => r.LeaderId)
.GroupBy(p => p.LeaderId, (id, item) => new { id, item })
.ToDictionary(q => q.id, q => q.item.ToList());
Tree PersonTree = new Tree();
void add_branch(treeNode node)
{
if (!data.ContainsKey(node.personNode.PersonId))
{
return;
}
List <PersonModel> branch = data[node.personNode.PersonId];
foreach (var p in branch)
{
treeNode pers = new treeNode(p);
node.add_children(pers);
add_branch(pers);
}
}
if (data.Count != 0)
{
List <PersonModel> root = data[-1];
foreach (var p in root)
{
treeNode node = new treeNode(p);
PersonTree.root.Add(node);
add_branch(node);
}
}
return(View(PersonTree));
}
private treeNode factor()
{
treeNode temp_factor = new treeNode();
switch (current_token.token_Type)
{
case tokenType.LeftParentheses:
match(tokenType.LeftParentheses);
temp_factor = exp();
match(tokenType.RightParentheses);
break;
case tokenType.Num:
temp_factor.nodekind = nodeKind.Exp;
temp_factor.expkind = expKind.Const;
temp_factor.exptype = expType.Integer;
temp_factor.tokentype = current_token;
temp_factor.val = Int32.Parse(current_token.token_Name);
match(tokenType.Num);
break;
case tokenType.ID:
temp_factor.nodekind = nodeKind.Exp;
temp_factor.expkind = expKind.Id;
temp_factor.exptype = expType.Integer;
temp_factor.tokentype = current_token;
temp_factor.name = current_token.token_Name;
match(tokenType.ID);
break;
default:
//error("");
break;
}
return(temp_factor);
}
//==================================================================================
public treeNode build_tree(int cId)
{
client clt = DB.client.Where(c => c.id == cId).Single();
//root
treeNode cTree = new treeNode();
cTree.id = clt.id;
cTree.name = clt.name;
cTree.Numfollow = (int)clt.num_followers;
if (clt.my_childs != null)
{
string myChildsIds = clt.my_childs;
List <string> myChildsIds_List = myChildsIds.Split(',').ToList();
foreach (string childId in myChildsIds_List)
{
int child_id = Int32.Parse(childId);
treeNode node = new treeNode();
node.id = child_id;
client ct = DB.client.Where(c => c.id == child_id).Single();
node.name = ct.name;
node.Numfollow = (int)ct.num_followers;
cTree.childs.Add(node);
complete_tree(node);//to can fill rest of the tree
}
}
return(cTree);
}
public ActionResult clientTree(int cId)
{
treeNode clientTree = build_tree(cId);
return(View(clientTree));
}
static void Main(string[] args)
{
Console.WriteLine("Scratch Pad to test my Data Sctuctures");
Node tracker;
int caseswitch = 9;
switch (caseswitch)
{
case 9:
try
{
string input = "SOSSPSSQSSOR";
marsExploration(input);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
break;
case 1:
#region "LinkedList"
try
{
Node n1 = new Node();
n1.setNodeValue(23);
n1.setNextNodePointerValue(null);
Node n2 = new Node();
n2.setNodeValue("Hello");
n2.setNextNodePointerValue(null);
Node n3 = new Node();
n3.setNodeValue(23.45);
n3.setNextNodePointerValue(null);
list l1 = new list();
l1.AddItem(n1);
l1.AddItem(n2);
l1.AddItem(n3);
l1.printAll();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
#endregion
break;
case 2:
try
{
//Create a tree, specifying each of the node values manually
// treeNode T1 = new treeNode();
// T1.createTreeNode(23);
// T1.rightchild = new treeNode().createTreeNode(45);
// T1.leftchild = new treeNode().createTreeNode(100);
// Console.WriteLine(T1);
//Create a tree from an array of values (no order, generate children by appearance in the array)
int[] data = { 7, 5, 10, 3, 6, 9, 12 };
treeNode T2 = new treeNode().GenerateTreeFromArray(data);
Console.WriteLine("Inorder traversal");
T2.inorder(T2);
Console.WriteLine("Preorder Traversal");
T2.preorder(T2);
Console.WriteLine("Postorder Traversal");
T2.postorder(T2);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
break;
case 3:
try
{
int[] a = { 1, 2, 3, 4, 5 };
int Total = 0;
Total += recursionPlayground.recurseAddMethod(a, 0);
Console.WriteLine(Total);
recursionPlayground.recurseTree(a, 0);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
break;
case 4:
try
{
int[] data = { 7, 5, 10, 3, 6, 9, 12 };
list T3 = new list();
Node result = T3.arrayTolist(data);
tracker = result;
int newnumber = 77;
list.insertNodeAtHead(tracker, newnumber);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
break;
case 5:
try
{
singleInteger s1 = new singleInteger();
int result = s1.retSingleIngeter(456777);
Console.WriteLine("Single digit result");
Console.WriteLine(result);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
break;
case 6:
try
{
reverseInteger s1 = new reverseInteger();
s1.reverseIntegerfunc(123);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
break;
case 7:
try
{
addArray a1 = new addArray();
int[] item = { 1, 2, 3, 4, 5 };
Console.WriteLine(a1.addArrayFunc(item, (item.Length) - 1));
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
break;
case 8:
try
{
int[,] a = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 }, { 13, 14, 15, 16 } };
int nrows = 4;
int ncols = 4;
for (int i = 0; i < ncols - 1; i++)
{
Console.WriteLine(a[0, i]);
}
for (int i = 0; i < nrows - 1; i++)
{
Console.WriteLine(a[i, ncols - 1]);
}
for (int i = ncols - 1; i > 0; i--)
{
Console.WriteLine(a[ncols - 1, i]);
}
for (int i = nrows - 1; i > 0; i--)
{
Console.WriteLine(a[i, 0]);
}
int[,] a1 = { { 6, 7 }, { 10, 11 } };
nrows = 2;
ncols = 2;
for (int i = 0; i < ncols - 1; i++)
{
Console.WriteLine(a1[0, i]);
}
for (int i = 0; i < nrows - 1; i++)
{
Console.WriteLine(a1[i, ncols - 1]);
}
for (int i = ncols - 1; i > 0; i--)
{
Console.WriteLine(a1[ncols - 1, i]);
}
for (int i = nrows - 1; i > 0; i--)
{
Console.WriteLine(a1[i, 0]);
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
break;
}
}
public void GetDbTable()
{
try
{
string dbname = ParamsData["database"];
SqlServer server = (SqlServer)sessionData["server"];
server.Connect();
SqlDatabase database = server.Databases[dbname];
SqlTableCollection tables = database.Tables;
SqlStoredProcedureCollection splist = database.StoredProcedures;
List <treeNode> tree = new List <treeNode>();
treeNode rootnode = new treeNode(-1, dbname);
rootnode.attributes = new Dictionary <string, object>();
rootnode.attributes.Add("type", "db");
rootnode.iconCls = "icon-db";
rootnode.children = new List <treeNode>();
treeNode rootnode2 = new treeNode(-2, "表");
if (tables.Count > 0)
{
rootnode2.state = "closed";
}
rootnode2.attributes = new Dictionary <string, object>();
rootnode2.attributes.Add("type", "");
rootnode2.iconCls = "";
rootnode.children.Add(rootnode2);//
//rootnode.children = new List<treeNode>();
treeNode rootnode3 = new treeNode(-3, "存储过程");
if (splist.Count > 0)
{
rootnode3.state = "closed";
}
rootnode3.attributes = new Dictionary <string, object>();
rootnode3.attributes.Add("type", "");
rootnode3.iconCls = "";
rootnode.children.Add(rootnode3);//
if (tables.Count > 0)
{
rootnode2.children = new List <treeNode>();
for (int i = 0; i < tables.Count; i++)
{
if (tables[i].TableType == SqlObjectType.User)
{
SqlColumnCollection columns = tables[i].Columns;
treeNode node = new treeNode(i, tables[i].Name);
if (columns.Count > 0)
{
node.state = "closed";
}
node.attributes = new Dictionary <string, object>();
node.attributes.Add("type", "table");
node.iconCls = "icon-table";
rootnode2.children.Add(node);
if (columns.Count > 0)
{
node.children = new List <treeNode>();
for (int k = 0; k < columns.Count; k++)
{
string defaultvalue = columns[k].ColumnInformation.DefaultValue == null ? "null" : columns[k].ColumnInformation.DefaultValue;
treeNode node2 = new treeNode(k, columns[k].ColumnInformation.Name + "(" + columns[k].ColumnInformation.DataType + "," + defaultvalue + ")");
node2.attributes = new Dictionary <string, object>();
node2.attributes.Add("type", "column");
if (columns[k].ColumnInformation.Key)
{
node2.iconCls = "icon-key";
}
else
{
node2.iconCls = "icon-column";
}
node.children.Add(node2);
}
}
}
}
}
if (splist.Count > 0)
{
rootnode3.children = new List <treeNode>();
for (int i = 0; i < splist.Count; i++)
{
if (splist[i].StoredProcedureType == SqlObjectType.StoredProcedure)
{
treeNode node = new treeNode(i, splist[i].Name);
node.attributes = new Dictionary <string, object>();
node.attributes.Add("type", "sp");
rootnode3.children.Add(node);
}
}
}
tree.Add(rootnode);
server.Disconnect();
JsonResult = ToTreeJson(tree);
}
catch (Exception err)
{
JsonResult = RetError("获取数据库相关数据错误：//n//r" + err.Message);
}
}
public void addChild(treeNode n)
{
children.Add(n);
}
