Files
using.cash/Site4/Controls/v4/WSOrgTree.ascx.cs
T

395 lines
10 KiB
C#

using System;
using System.Collections;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Web;
using System.Web.Script.Services;
using System.Web.Security;
using System.Web.Services;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using Activizr.Basic.Enums;
using Activizr.Basic.Types;
using Activizr.Logic.Cache;
using Activizr.Logic.Security;
using Activizr.Logic.Structure;
using Telerik.Web.UI;
public partial class Controls_v4_WSOrgTree : System.Web.UI.UserControl
{
public int topSortCountryId=0;
public RadTreeView tree
{
get { return Tree; }
}
public string Skin
{
get
{
return tree.Skin;
}
set
{
tree.Skin = value;
}
}
public int RootId
{
get
{
return Root.Identity;
}
set
{
if (root == null || root.Identity != value)
{
Root = Organization.FromIdentity(value);
}
}
}
protected void Page_Load (object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
Populate(4);
}
}
private RadTreeViewEventHandler selectedNodeChanged;
public RadTreeViewEventHandler SelectedNodeChanged
{
get
{
return selectedNodeChanged;
}
set
{
if (value != selectedNodeChanged)
{
if (selectedNodeChanged != null)
{
Tree.NodeClick -= selectedNodeChanged;
selectedNodeChanged = null;
}
if (value != null)
{
Tree.NodeClick += value;
selectedNodeChanged = value;
}
}
}
}
public Organization SelectedOrganization
{
get
{
string selectedIdentity = Tree.SelectedValue;
if (String.IsNullOrEmpty(selectedIdentity))
{
return null;
}
return Organization.FromIdentity(Int32.Parse(selectedIdentity));
}
set
{
try
{
//get the line to make sure all nodes down to the selected are loaded;
BasicOrganization[] line = OrganizationCache.GetOrganizationLine(value.Identity);
if (Tree.Nodes.Count == 0)
{
// Tree is empty, insert the root.
RadTreeNode rootNode = new RadTreeNode(this.Root.Name, this.Root.Identity.ToString());
SetAuthorityForNode(rootNode);
Tree.Nodes.Add(rootNode);
}
BasicOrganization parentbg = (BasicOrganization)this.Root;
RadTreeNodeCollection parentCollection = Tree.Nodes[0].Nodes;
foreach (BasicOrganization bg in line)
{
RadTreeNode nod = Tree.FindNodeByValue(bg.Identity.ToString());
// if node found that parent is already loaded
if (nod == null)
{
AddChildren(parentCollection, parentbg.Identity);
nod = Tree.FindNodeByValue(bg.Identity.ToString());
nod.Expanded = true;
nod.Selected = true;
}
parentbg = bg;
parentCollection = nod.Nodes;
}
Tree.Nodes[0].Expanded = true;
}
catch
{
//nada
}
}
}
private Authority authority = null;
private Permission requiredPermission = Permission.Undefined;
public void SetAuthority (Authority pAuthority, Permission pRequiredPermission)
{
authority = pAuthority;
requiredPermission = pRequiredPermission;
foreach (RadTreeNode nod in Tree.GetAllNodes())
{
SetAuthorityForNode(nod);
}
}
private void SetAuthorityForNode (RadTreeNode nod)
{
if (authority != null)
{
nod.Attributes["uid"] = authority.PersonId.ToString();
nod.Attributes["perm"] = requiredPermission.ToString();
int org = int.Parse(nod.Value);
if (!authority.HasPermission(requiredPermission, org, -1, Authorization.Flag.AnyGeography))
nod.CssClass = "nonAccessNode";
}
}
public int SelectedOrganizationId
{
get
{
if (SelectedOrganization != null)
return SelectedOrganization.Identity;
else
return 0;
}
set
{
SelectedOrganization = Organization.FromIdentity(value);
}
}
public bool CheckBoxes
{
get
{
return Tree.CheckBoxes = true;
}
set
{
Tree.CheckBoxes = value;
}
}
public int[] CheckedValues
{
get
{
List<int> res = new List<int>();
foreach (RadTreeNode node in Tree.CheckedNodes)
{
res.Add(int.Parse(node.Value));
}
return res.ToArray();
}
set
{
Tree.ClearCheckedNodes();
foreach (int v in value)
{
RadTreeNode found = VerifyValueLoaded(v);
if (found != null && found.Checkable)
{
found.Checked = true;
}
}
}
}
private RadTreeNode VerifyValueLoaded (int v)
{
RadTreeNode node = Tree.FindNodeByValue(v.ToString());
SelectedOrganizationId = v;
node = Tree.FindNodeByValue(v.ToString());
return node;
}
private void Populate (int levels)
{
if (root == null)
{
root = Organization.Root;
}
Organizations orgs = root.GetTree();
// We need a real fucking tree structure.
Dictionary<int, Organizations> lookup = new Dictionary<int, Organizations>();
foreach (Organization org in orgs)
{
if (!lookup.ContainsKey(org.ParentIdentity))
{
lookup[org.ParentIdentity] = new Organizations();
}
lookup[org.ParentIdentity].Add(org);
}
//Sort rootlevel
if (lookup.ContainsKey(Organization.RootIdentity))
{
lookup[Organization.RootIdentity].Sort(
delegate(Organization o1, Organization o2)
{
if (o1.DefaultCountryId != topSortCountryId && o2.DefaultCountryId != topSortCountryId)
return 0;
else if (o1.DefaultCountryId != topSortCountryId && o2.DefaultCountryId == topSortCountryId)
return 1;
else if (o1.DefaultCountryId == topSortCountryId && o2.DefaultCountryId != topSortCountryId)
return -1;
else
return 0;
});
}
Tree.Nodes.Add(RecursiveAdd(lookup, orgs[0].ParentIdentity, levels - 1)[0]);
Tree.Nodes[0].Expanded = true;
Tree.Nodes[0].Selected = true;
}
private void AddChildren (RadTreeNodeCollection coll, int parentIdentity)
{
BasicOrganization[] orgs = OrganizationCache.GetOrganizationChildren(parentIdentity);
foreach (BasicOrganization org in orgs)
{
RadTreeNode node = new RadTreeNode(org.Name, org.Identity.ToString());
SetAuthorityForNode(node);
node.ExpandMode = TreeNodeExpandMode.WebService;
coll.Add(node);
}
}
private RadTreeNodeCollection RecursiveAdd (Dictionary<int, Organizations> lookup, int parentIdentity, int levels)
{
RadTreeNodeCollection result = new RadTreeNodeCollection(this.Tree);
foreach (Organization org in lookup[parentIdentity])
{
RadTreeNode node = new RadTreeNode(org.Name, org.Identity.ToString());
SetAuthorityForNode(node);
if (lookup.ContainsKey(org.Identity) && (levels > 0))
{
RadTreeNodeCollection collection = RecursiveAdd(lookup, org.Identity, levels - 1);
foreach (RadTreeNode subnode in collection)
{
node.Nodes.Add(subnode);
}
}
if (levels > 0)
node.Expanded = true;
if (levels < 1)
node.ExpandMode = TreeNodeExpandMode.WebService;
result.Add(node);
}
return result;
}
public Organization Root
{
get
{
if (this.root == null)
{
return Organization.Root;
}
else
return root;
}
set
{
if (this.root == null || this.root.Identity != value.Identity)
{
this.root = value;
if (Tree.Nodes.Count > 0)
{
Tree.Nodes.Clear();
}
Populate(3);
}
}
}
public string OnClientNodeClicking
{
set { Tree.OnClientNodeClicking = value; }
get { return Tree.OnClientNodeClicking; }
}
public string ParentClientID
{
set { this.parentClientID = value; }
get { return this.parentClientID; }
}
private string parentClientID;
private Organization root;
public static void EmitScripts (Control page)
{
ScriptManager.RegisterClientScriptBlock(page, page.GetType(), "OrgTree_NodeClicking",
@"
;function OrgTree_NodeClicking(sender, args) {
// ugly hack to get this to work in FF
if (typeof (DropOrganizations_OnClientNodeClicking) == 'function')
DropOrganizations_OnClientNodeClicking(sender, args);
};
", true);
}
}