/// <summary>
/// 根据数据库记录选择当前人员拥有的常规功能菜单权限
/// </summary>
protected void BindCheckedMenu()
{
var list = WebLoginInfoBLL.Instance.GetFuncsByID("" + UserId);
for (int i = 0; i < list.Count; i++)
{
TreeNode node = TreeNodeHelper.GetChildNodeByID(tvMenu.Nodes[0], "" + list[i]);
if (node != null)
{
node.Checked = true;
}
//暂时没找的好的方法，只能用最笨的遍历了
//foreach (TreeNode menuNode in tvMenu.Nodes[0].ChildNodes)
//{
// foreach (TreeNode node in menuNode.ChildNodes)
// {
// if (node.Value == ""+list[i])
// {
// node.Checked = true;
// break;
// }
// }
//}
}
}
private void PopulateControls()
{
cmbEntity.Items.Clear();
var entities = form.GetDisplayEntities();
if (entities != null)
{
foreach (var entity in entities)
{
cmbEntity.Items.Add(entity.Value.LogicalName);
}
}
var parententityname = TreeNodeHelper.GetAttributeFromNode(node.Parent, "name");
if (form.NeedToLoadEntity(parententityname))
{
if (!form.working)
{
form.LoadEntityDetails(parententityname, RefreshRelationships);
}
}
else
{
RefreshRelationships();
}
RefreshAttributes();
}
public string AllAuthTreeNode_json()
{
List <Authority> allauth = authoritySer.GetAllAuth();
TreeNodeHelper nodeHelper = new TreeNodeHelper();
return(nodeHelper.InitTreeNode_json(allauth, 0, true));
}
private void DisplayFormXml()
{
XmlNode formXmlEditorXmlNode = siteMapDoc.DocumentElement;
tvSiteMap.Nodes.Clear();
/* Add Annotation
* bool addAnotationsNode = true;
* //Add Annotation
* foreach (XmlNode node in formXmlEditorXmlNode.ChildNodes)
* {
* if(node.Name.ToLower() == "annotations")
* {
* addAnotationsNode = false;
* }
* }
*
* if(addAnotationsNode)
* {
*
* XmlNode annotationNode = siteMapDoc.CreateElement("Annotations");
* XmlNode textAnnotation = siteMapDoc.CreateElement("TextAnnotation");
* annotationNode.AppendChild(textAnnotation);
*
* formXmlEditorXmlNode.AppendChild(annotationNode);
* }*/
TreeNodeHelper.AddTreeViewNode(tvSiteMap, formXmlEditorXmlNode, this);
// ManageMenuDisplay();
tvSiteMap.Nodes[0].Expand();
}
public valueControl(TreeNode node, FetchXmlBuilder fetchXmlBuilder, TreeBuilderControl tree)
{
InitializeComponent();
InitializeFXB(null, fetchXmlBuilder, tree, node);
_attributeName = TreeNodeHelper.GetAttributeFromNode(Node.Parent, "attribute");
_entityName = TreeNodeHelper.GetAttributeFromNode(Node.Parent, "entity");
if (String.IsNullOrWhiteSpace(_entityName))
{
_entityName = TreeNodeHelper.GetAttributeFromNode(Node.Parent.Parent.Parent, "name");
}
else
{
// TODO: Entity is an alias, get the actual entity name
}
if (fxb.NeedToLoadEntity(_entityName))
{
if (!fxb.working)
{
fxb.LoadEntityDetails(_entityName, RefreshValues);
}
}
else
{
RefreshValues();
}
}
public void Children_Property_Passes()
{
var node = new TreeNodeHelper <int>();
{
node.Children.Add(
TreeNodeHelper <int> .Create(100)
, TreeNodeHelper <int> .Create(200)
, TreeNodeHelper <int> .Create(300));
AssertionUtils.AssertEnumerable(
new int[] {
100, 200, 300
}
, node.Children.Select(_c => _c.Value)
, ""
);
Assert.IsTrue(node.Children.All(_c => _c.Parent == node));
}
{
node.Children.RemoveAt(1);
AssertionUtils.AssertEnumerable(
new int[] {
100, 300
}
, node.Children.Select(_c => _c.Value)
, ""
);
Assert.IsTrue(node.Children.All(_c => _c.Parent == node));
}
}
public void IEnumerable_Passes()
{
var node = new TreeNodeHelper <int>();
node.Children.Add(
node.CreateNode(10)
, node.CreateNode(20)
, node.CreateNode(30));
node[0].Children.Add(
node.CreateNode(100)
, node.CreateNode(200));
node[2].Children.Add(
node.CreateNode(100));
AssertionUtils.AssertEnumerable(
new TreeNodeHelper <int>[] {
node,
node.Children[0], node.Children[0][0], node.Children[0][1],
node.Children[1],
node.Children[2], node.Children[2][0]
}
, node
, ""
);
}
public void IEnumerable_GetValueEnueramble_Passes()
{
var node = new TreeNodeHelper <int>();
node.Children.Add(
node.CreateNode(10
, node.CreateNode(100)
, node.CreateNode(200)
)
, node.CreateNode(20)
, node.CreateNode(30
, node.CreateNode(100)
)
);
AssertionUtils.AssertEnumerable(
new TreeNodeHelper <int>[] {
node,
node.Children[0], node.Children[0][0], node.Children[0][1],
node.Children[1],
node.Children[2], node.Children[2][0]
}.Select(_n => _n.Value)
, node.GetValueEnumerable()
, ""
);
}
private void DisplayEmailTemplate()
{
XmlNode emailTemplateEditorXmlNode = siteMapDoc.DocumentElement;
tvSiteMap.Nodes.Clear();
/* Add Annotation
bool addAnotationsNode = true;
//Add Annotation
foreach (XmlNode node in emailTemplateEditorXmlNode.ChildNodes)
{
if(node.Name.ToLower() == "annotations")
{
addAnotationsNode = false;
}
}
if(addAnotationsNode)
{
XmlNode annotationNode = siteMapDoc.CreateElement("Annotations");
XmlNode textAnnotation = siteMapDoc.CreateElement("TextAnnotation");
annotationNode.AppendChild(textAnnotation);
emailTemplateEditorXmlNode.AppendChild(annotationNode);
}*/
TreeNodeHelper.AddTreeViewNode(tvSiteMap, emailTemplateEditorXmlNode, this);
// ManageMenuDisplay();
tvSiteMap.Nodes[0].Expand();
}
private void CtrlSaving(object sender, SaveEventArgs e)
{
tvSiteMap.SelectedNode.Tag = e.AttributeCollection;
string nodeFullName = TreeNodeHelper.FullNodeName(tvSiteMap.SelectedNode);
if (nodeFullName == "Series.Series")
{
if (e.AttributeCollection.ContainsKey("EmailTemplateType"))
{
EmailTemplateType = e.AttributeCollection["EmailTemplateType"].Value;
}
}
var doc = new XmlDocument();
XmlNode rootNode = doc.CreateElement("parent");
doc.AppendChild(rootNode);
AddXmlNode(tvSiteMap.Nodes[0], rootNode);
// var tmpDoc = doc.ChildNodes[0].ChildNodes[0].OuterXml;
EmailTemplateXML = doc.ChildNodes[0].ChildNodes[0].OuterXml;
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
//初始化商户树节点
TreeNode root = TreeNodeHelper.InitializeTree("");
e.Result = root;
}
public void Children_OnMovedChild_Passes()
{
var node = new TreeNodeHelper <int>();
node.Children.Add(
node.CreateNode(0)
, node.CreateNode(1)
, node.CreateNode(2));
int callCounter = 0;
(TreeNodeHelper <int> self, TreeNodeHelper <int> child, int fromIndex, int toIndex)recievedValues = default;
node.OnMovedChild.Add((_s, _c, _from, _to) => {
callCounter++;
recievedValues = (_s, _c, _from, _to);
});
node.OnMovedChild.Add((_, __, ___, ____) => throw new System.Exception());
Debug.Log($"test -- childCount={node.ChildCount}");
var moveFromIndex = 1;
var moveToIndex = 2;
var fromChild = node[moveFromIndex];
Assert.DoesNotThrow(() => node.Children.MoveTo(moveFromIndex, moveToIndex));
Assert.AreEqual(1, callCounter);
Assert.AreSame(node, recievedValues.self);
Assert.AreEqual(moveFromIndex, recievedValues.fromIndex);
Assert.AreEqual(moveToIndex, recievedValues.toIndex);
Assert.AreSame(node[moveToIndex], recievedValues.child);
Assert.AreSame(fromChild, recievedValues.child);
}
public void Parent_OnChangedParent_Passes()
{
{
var callbacks = new SmartDelegate <Callback>();
var c = 0;
callbacks.Add((_) => c++);
callbacks.Add((_) => { });
callbacks.SafeDynamicInvoke(0, () => "test fail...");
}
var node = new TreeNodeHelper <int>();
int callCounter = 0;
(TreeNodeHelper <int> self, TreeNodeHelper <int> parent, TreeNodeHelper <int> prevParent)recievedValue = default;
node.OnChangedParent.Add((_s, _p, _prev) => {
callCounter++;
recievedValue = (_s, _p, _prev);
});
node.OnChangedParent.Add((_, __, ___) => throw new System.Exception());
var parent = node.CreateNode(100);
Assert.DoesNotThrow(() => {
node.Parent = parent;
});
Assert.AreEqual(1, callCounter);
Assert.AreSame(node, recievedValue.self);
Assert.AreSame(parent, recievedValue.parent);
Assert.IsNull(recievedValue.prevParent);
}
private void RefreshRelationships()
{
cmbRelationship.Items.Clear();
var parententityname = TreeNodeHelper.GetAttributeFromNode(Node.Parent, "name");
var entities = fxb.GetDisplayEntities();
if (entities != null && entities.ContainsKey(parententityname))
{
var parententity = entities[parententityname];
var mo = parententity.ManyToOneRelationships;
var om = parententity.OneToManyRelationships;
var mm = parententity.ManyToManyRelationships;
var list = new List <EntityRelationship>();
if (mo.Length > 0)
{
cmbRelationship.Items.Add("- M:1 -");
list.Clear();
foreach (var rel in mo)
{
list.Add(new EntityRelationship(rel, EntityRole.Referencing, parententityname, fxb));
}
list.Sort();
cmbRelationship.Items.AddRange(list.ToArray());
}
if (om.Length > 0)
{
cmbRelationship.Items.Add("- 1:M -");
list.Clear();
foreach (var rel in om)
{
list.Add(new EntityRelationship(rel, EntityRole.Referenced, parententityname, fxb));
}
list.Sort();
cmbRelationship.Items.AddRange(list.ToArray());
}
if (mm.Length > 0)
{
var greatparententityname = Node.Parent.Parent != null?TreeNodeHelper.GetAttributeFromNode(Node.Parent.Parent, "name") : "";
cmbRelationship.Items.Add("- M:M -");
list.Clear();
foreach (var rel in mm)
{
if (rel.Entity1LogicalName == parententityname ||
rel.Entity1LogicalName == greatparententityname && rel.IntersectEntityName == parententityname)
{
list.Add(new EntityRelationship(rel, EntityRole.Referencing, parententityname, fxb, greatparententityname));
}
if (rel.Entity2LogicalName == parententityname ||
rel.Entity2LogicalName == greatparententityname && rel.IntersectEntityName == parententityname)
{
list.Add(new EntityRelationship(rel, EntityRole.Referenced, parententityname, fxb, greatparententityname));
}
}
list.Sort();
cmbRelationship.Items.AddRange(list.ToArray());
}
}
}
public void Children_OnRemovedChild_Passes()
{
var node = new TreeNodeHelper <int>();
node.Children.Add(node.CreateNode(0), node.CreateNode(1));
int callCounter = 0;
(TreeNodeHelper <int> self, TreeNodeHelper <int> child, int index)recievedValues = default;
node.OnRemovedChild.Add((_s, _c, _i) => {
callCounter++;
recievedValues = (_s, _c, _i);
});
node.OnRemovedChild.Add((_, __, ___) => throw new System.Exception());
var removeIndex = node.ChildCount - 1;
var removeChild = node[removeIndex];
Assert.DoesNotThrow(() => node.Children.RemoveAt(removeIndex));
Assert.AreEqual(1, callCounter);
Assert.AreSame(node, recievedValues.self);
Assert.AreEqual(removeIndex, recievedValues.index);
Assert.AreSame(removeChild, recievedValues.child);
}
public EntityNode(TreeNode node)
{
EntityName = TreeNodeHelper.GetAttributeFromNode(node, "name");
var alias = TreeNodeHelper.GetAttributeFromNode(node, "alias");
name = !string.IsNullOrEmpty(alias) ? alias : EntityName;
}
public void Save()
{
try
{
if (ValidateForm())
{
if (cmbOperator.SelectedItem != null && cmbOperator.SelectedItem is OperatorItem)
{
var oper = (OperatorItem)cmbOperator.SelectedItem;
if (oper.IsMultipleValuesType && !string.IsNullOrWhiteSpace(cmbValue.Text))
{
// Now we need to generate value nodes under this node instead of just adding the value
foreach (var valuestr in cmbValue.Text.Split(','))
{
var value = valuestr.Trim();
var attrNode = TreeNodeHelper.AddChildNode(node, "value");
var coll = new Dictionary <string, string>();
coll.Add("#text", value);
attrNode.Tag = coll;
TreeNodeHelper.SetNodeText(attrNode, FetchXmlBuilder.friendlyNames);
}
cmbValue.Text = "";
}
}
Dictionary <string, string> collection = ControlUtils.GetAttributesCollection(this.Controls, true);
SendSaveMessage(collection);
controlsCheckSum = ControlUtils.ControlsChecksum(this.Controls);
}
}
catch (ArgumentNullException ex)
{
MessageBox.Show(ex.Message, "Validation", MessageBoxButtons.OK, MessageBoxIcon.Stop);
}
}
private void RefreshAttributes()
{
cmbFrom.Items.Clear();
cmbTo.Items.Clear();
if (cmbEntity.SelectedItem != null)
{
var linkentity = cmbEntity.SelectedItem.ToString();
var linkAttributes = form.GetDisplayAttributes(linkentity);
foreach (var attribute in linkAttributes)
{
if (attribute.IsPrimaryId == true ||
attribute.AttributeType == AttributeTypeCode.Lookup ||
attribute.AttributeType == AttributeTypeCode.Customer ||
attribute.AttributeType == AttributeTypeCode.Owner)
{
cmbFrom.Items.Add(attribute.LogicalName);
}
}
}
var parententity = TreeNodeHelper.GetAttributeFromNode(node.Parent, "name");
var parentAttributes = form.GetDisplayAttributes(parententity);
foreach (var attribute in parentAttributes)
{
if (attribute.IsPrimaryId == true ||
attribute.AttributeType == AttributeTypeCode.Lookup ||
attribute.AttributeType == AttributeTypeCode.Customer ||
attribute.AttributeType == AttributeTypeCode.Owner)
{
cmbTo.Items.Add(attribute.LogicalName);
}
}
}
public void Test_Stack(string arrStr, bool expected)
{
var root = TreeNodeHelper.BuildTree(arrStr);
var sol = new Solution_Stack();
var res = sol.IsValidBST(root);
Assert.AreEqual(res, expected);
}
public void Test_Generic(string treeStr, int expected)
{
var root = TreeNodeHelper.BuildTree(treeStr);
var sol = new Solution();
var res = sol.SumRootToLeaf(root);
Assert.AreEqual(res, expected);
}
public void Value_Property_Passes()
{
var node = new TreeNodeHelper <int>(100);
Assert.AreEqual(100, node.Value);
node.Value = 200;
Assert.AreEqual(200, node.Value);
}
public void Test_GenericStr(string treeStr, bool expected)
{
var root = TreeNodeHelper.BuildTree(treeStr);
var sol = new Solution();
var res = sol.IsEvenOddTree(root);
Assert.AreEqual(res, expected);
}
public void Test_Generic(string nodeStr, int expected)
{
var node = TreeNodeHelper.BuildTree(nodeStr);
var sol = new Solution();
var res = sol.MaxAncestorDiff(node);
Assert.AreEqual(res, expected);
}
public void Test_Generic(string strArr, int expected)
{
var root = TreeNodeHelper.BuildTree(strArr);
var sol = new Solution();
var res = sol.SumNumbers(root);
Assert.AreEqual(res, expected);
}
public void Test_Generic(string treeStr, string expected)
{
var root = TreeNodeHelper.ToNode(TreeNodeHelper.BuildTree(treeStr));
var sol = new Solution();
var res = sol.Connect(root);
Assert.AreEqual(TreeNodeHelper.PrintNode(res), expected);
}
public void Test_Generic(string strArray, int target, int expected)
{
var root = TreeNodeHelper.BuildTree(strArray);
var sol = new Solution();
var res = sol.PathSum(root, target);
Assert.AreEqual(res, expected);
}
public string GetUserAuthority(int userid, string port)
{
AuthorityService authority = new AuthorityService();
var auth = authority.GetUserAuth(userid.ToString(), port);
TreeNodeHelper tNH = new TreeNodeHelper();
string str = tNH.InitTreeNode_json(auth, 0, false);
return(str);
}
public void Test_DFS(string treeStr, int expected)
{
var root = TreeNodeHelper.BuildTree(treeStr);
var sol = new Solution_DFS();
var res = sol.DeepestLeavesSum(root);
Assert.AreEqual(expected, res);
}
public void Test_Stack(string treeStr, int expected)
{
var head = TreeNodeHelper.BuildTree(treeStr);
var sol = new Solution();
var res = sol.Rob(head);
Assert.AreEqual(res, expected);
}
public void Constructor_Passes()
{
var node = new TreeNodeHelper <int>();
Assert.IsNull(node.Parent);
Assert.IsFalse(node.Children.Any());
Assert.AreEqual(0, node.ChildCount);
Assert.AreEqual(default(int), node.Value);
}
