/// <summary>
/// 지정한 Node Container가 TreeView라면 Nodes 들을 열거하고, TreeNode라면 자신을 반환한다.
/// </summary>
/// <param name="nodeContainer"></param>
/// <returns></returns>
public static IEnumerable <RadTreeNode> GetRootNodesOrSelfNode(this IRadTreeNodeContainer nodeContainer)
{
if (IsDebugEnabled)
{
log.Debug(@"지정한 Node Container가 TreeView라면 Nodes 들을 열거하고, TreeNode라면 자신을 반환한다. nodeContainer=[{0}]", nodeContainer.AsTextAndValue());
}
if (nodeContainer == null)
{
yield break;
}
if (nodeContainer is RadTreeNode)
{
yield return((RadTreeNode)nodeContainer);
}
else if (nodeContainer is RadTreeView)
{
var rootNodes = ((RadTreeView)nodeContainer).Nodes;
foreach (RadTreeNode node in rootNodes)
{
yield return(node);
}
}
}
/// <summary>
/// 특정 NodeContainer가 TreeView라면 자식 Nodes들을 열거하고, TreeNode라면, TreeNode가 속한 TreeView의 Root Nodes 들을 반환합니다.
/// </summary>
/// <param name="nodeContainer"></param>
/// <returns></returns>
public static IEnumerable <RadTreeNode> FindRootNodes(this IRadTreeNodeContainer nodeContainer)
{
if (IsDebugEnabled)
{
log.Debug("특정 NodeContainer가 TreeView라면 자식 Nodes들을 열거하고, TreeNode라면, TreeNode가 속한 TreeView의 Root Nodes 들을 반환합니다... " +
"nodeContainer=[{0}]", nodeContainer.AsTextAndValue());
}
RadTreeView radTreeView = null;
if (nodeContainer is RadTreeView)
{
radTreeView = (RadTreeView)nodeContainer;
}
else if (nodeContainer is RadTreeNode)
{
radTreeView = ((RadTreeNode)nodeContainer).TreeView;
}
if (radTreeView != null)
{
return(radTreeView.Nodes.Cast <RadTreeNode>());
}
return(Enumerable.Empty <RadTreeNode>());
}
/// <summary>
/// 엔티티를 로드하고, IRadTreeNodeContainer에 자식노드로 추가한다.
/// </summary>
/// <param name="node">선택된 IRadTreeNodeContainer</param>
/// <param name="exceptionAction">예외발생 시 수행할 Action</param>
protected virtual void LoadAndAddEntity(IRadTreeNodeContainer node, Action <Exception> exceptionAction)
{
if (IsDebugEnabled)
{
log.Debug(@"==>S 엔티티[{0}] 목록을 로드하여, TreeView에 바인딩 시킵니다...", ConcreteType.Name);
}
node.ShouldNotBeNull("선택된 IRadTreeNodeContainer정보가 없습니다.");
try
{
LoadEntity(node);
AddEntity(node);
}
catch (Exception ex)
{
var errorMsg = string.Format(@"엔티티[{0}]를 로드하고, Binding 시에 예외가 발생했습니다.", ConcreteType.Name);
if (log.IsErrorEnabled)
{
log.ErrorException(errorMsg, ex);
}
if (exceptionAction != null)
{
exceptionAction(ex);
}
else
{
WebAppTool.MessageBox(errorMsg, this);
}
}
}
protected void btnAddNode_Click(object sender, EventArgs e)
{
Model.OrganiztionRole org = new Model.OrganiztionRole();
IRadTreeNodeContainer target = trvChart;
int ParrentOrganizationRoleId = -1, OrganizationRoleId;
if (string.IsNullOrEmpty(cmbOrganizationRoles.SelectedValue))
{
// Helpers.ContextHelpers.ShowMessage(this.Page, "یک نقش سازمانی انتخاب نمایید");
return;
}
if (trvChart.SelectedNode != null)
{
trvChart.SelectedNode.Expanded = true;
target = trvChart.SelectedNode;
ParrentOrganizationRoleId = trvChart.SelectedNode.Attributes["OrganizationRoleId"].ToInt32();
}
OrganizationRoleId = cmbOrganizationRoles.SelectedValue.ToInt32();
if (org.SetParrentId(ParrentOrganizationRoleId, OrganizationRoleId) != -1)
{
RadTreeNode addedNode = new RadTreeNode(cmbOrganizationRoles.SelectedText);
addedNode.ToolTip = string.Format("شماره نقش{0}", cmbOrganizationRoles.SelectedValue);
addedNode.Attributes.Add("OrganizationRoleId", cmbOrganizationRoles.SelectedValue);
addedNode.Selected = true;
target.Nodes.Add(addedNode);
}
}
/// <summary>
/// nodeContainer의 자신과 자손 TreeNode를 폭 우선 탐색 방식으로 열거합니다.
/// </summary>
/// <param name="nodeContainer"></param>
/// <returns></returns>
public static IEnumerable <RadTreeNode> GetNodesByBreadthFirst(this IRadTreeNodeContainer nodeContainer)
{
if (nodeContainer == null)
{
yield break;
}
if (IsDebugEnabled)
{
log.Debug(@"특정 NodeContainer를 폭 우선 탐색을 수행합니다. nodeContainer=[{0}]", nodeContainer.AsTextAndValue());
}
// CollectionExtensions.GraphBreadthFirstScan() 을 사용할 수 있지만, TreeView의 RootNode가 여러 개라면, 폭 우선 탐색이 되지 않는다.
// 그래서 여기서 전체를 다 구현했다.
var toScan = new Queue <RadTreeNode>(GetRootNodesOrSelfNode(nodeContainer));
var scanned = new HashSet <RadTreeNode>();
while (toScan.Count > 0)
{
RadTreeNode current = toScan.Dequeue();
yield return(current);
scanned.Add(current);
foreach (RadTreeNode item in current.Nodes.Cast <RadTreeNode>())
{
if (scanned.Contains(item) == false)
{
toScan.Enqueue(item);
}
}
}
}
protected void btnAddNode_Click(object sender, EventArgs e)
{
global::AccessManagementService.Model.OrganiztionRole org = new global::AccessManagementService.Model.OrganiztionRole();
IRadTreeNodeContainer target = trvChart;
int?ParrentOrganizationRoleId = -1;
int OrganizationRoleId;
if (string.IsNullOrEmpty(cmbOrganizationRoles.SelectedValue))
{
// Helpers.ContextHelpers.ShowMessage(this.Page, "یک نقش سازمانی انتخاب نمایید");
return;
}
OrganizationRoleId = cmbOrganizationRoles.SelectedValue.ToInt32();
if (trvChart.SelectedNode != null)
{
trvChart.SelectedNode.Expanded = true;
target = trvChart.SelectedNode;
ParrentOrganizationRoleId = trvChart.SelectedNode.Attributes["OrganizationRoleId"].ToInt32();
}
else
{
ParrentOrganizationRoleId = null; //very important to set first node's parrent id to null
}
// org.SetParrentId( OrganizationRoleId,ParrentOrganizationRoleId); no more need because all deparment mabe use this org
RadTreeNode addedNode = new RadTreeNode(cmbOrganizationRoles.SelectedText);
addedNode.ToolTip = string.Format("شماره نقش{0}", cmbOrganizationRoles.SelectedValue);
addedNode.Attributes.Add("OrganizationRoleId", cmbOrganizationRoles.SelectedValue);
addedNode.Selected = true;
target.Nodes.Add(addedNode);
//cmbOrganizationRoles.DataBind();
}
/// <summary>
/// <see cref="ITreeNodeEntity{T}"/>를 구현한 엔티티들을 표현할 TreeNode를 생성하여 TreeView에 추가합니다.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="parent">부모 노드 또는 TreeView</param>
/// <param name="nodeFactory">TreeNode를 생성하는 Factory 함수</param>
/// <param name="findNodeFunc">기존 TreeView에서 엔티티와 관련된 Node를 찾는 함수</param>
/// <param name="nodeAddedAction">TreeNode 하나를 추가할 때마다 수행하는 Action</param>
/// <param name="items">엔티티</param>
public static void BuildTreeNodes <T>(this IRadTreeNodeContainer parent,
Func <T, RadTreeNode> nodeFactory,
Func <T, RadTreeNode> findNodeFunc,
Action <T, RadTreeNode> nodeAddedAction,
IEnumerable <T> items) where T : class, ITreeNodeEntity <T>
{
BuildTreeNodes(parent, nodeFactory, findNodeFunc, nodeAddedAction, items, false);
}
/// <summary>
/// parent Container에 <see cref="Entities"/>값을 자식으로 추가한다.
/// </summary>
protected virtual void AddEntity(IRadTreeNodeContainer parent)
{
if (IsDebugEnabled)
{
log.Debug(@"==>S EntityGrid에 로딩된 Entity[{0}] 컬렉션을 Binding합니다...", ConcreteType.Name);
}
TreeViewAdapter.AddNodes(parent, Entities);
}
/// <summary>
/// 지정된 노드에 Tree를 추가합니다.
/// </summary>
/// <param name="parent"></param>
/// <param name="items"></param>
public virtual void AddNodes(IRadTreeNodeContainer parent, IEnumerable <T> items)
{
if (IsDebugEnabled)
{
log.Debug(@"지정된 엔티티들을 TreeView의 노드로 추가합니다... parent={0}, items={1}",
parent, items.CollectionToString());
}
TelerikTool.AddNodes(parent ?? TreeViewCtrl, CreateNode, NodeAdded, items);
}
/// <summary>
/// 특정 NodeContainer의 자손 중 자식 노드가 없는 TreeNode들 (나무 잎) 을 열거합니다.
/// </summary>
/// <param name="nodeContainer"></param>
/// <returns></returns>
public static IEnumerable <RadTreeNode> FindLeafNodes(this IRadTreeNodeContainer nodeContainer)
{
nodeContainer.ShouldNotBeNull("nodeContainer");
if (IsDebugEnabled)
{
log.Debug(@"특정 NodeContainer 하위의 모든 Leaf Node (자식이 없는 노드) 들을 Depth First 방식으로 찾습니다. nodeContainer=[{0}]", nodeContainer.AsTextAndValue());
}
return(nodeContainer.GetDescendentNodes().Where(n => n.Nodes.Count == 0));
}
/// <summary>
/// 지정된 노드에 Tree를 추가합니다.
/// </summary>
/// <param name="parent"></param>
/// <param name="items"></param>
public override void AddNodes(IRadTreeNodeContainer parent, IEnumerable <T> items)
{
if (IsDebugEnabled)
{
log.Debug(@"지정된 엔티티들을 TreeView의 노드로 추가합니다... parent={0}, items={1}",
parent, items.CollectionToString());
}
if (items != null)
{
(parent ?? TreeViewCtrl).BuildTreeNodes(CreateNode, FindNodeByItem, NodeAdded, items);
}
}
/// <summary>
/// Depth-First 탐색으로 특정 Node 와 그 자손 Node 들 중에 검사를 통과하는 Node들을 열거합니다.
/// </summary>
/// <param name="nodeContainer"></param>
/// <param name="predicate"></param>
/// <returns></returns>
public static IEnumerable <RadTreeNode> FindNodes(this IRadTreeNodeContainer nodeContainer, Func <RadTreeNode, bool> predicate)
{
nodeContainer.ShouldNotBeNull("nodeContainer");
predicate.ShouldNotBeNull("predicate");
if (IsDebugEnabled)
{
log.Debug("특정 NodeContainer(TreeView or TreeNode)부터 predicate를 만족하는 RadTreeNode 들을 모두 열거합니다. nodeContainer=[{0}]",
nodeContainer.AsTextAndValue());
}
return(nodeContainer.GetDescendentNodes().Where(predicate));
}
/// <summary>
/// 특정 값을 가진 TreeNode를 찾습니다. 없으면 null을 반환합니다.
/// </summary>
/// <param name="nodeContainer">RadTreeView or RadTreeNode</param>
/// <param name="nodeValue">찾을 node value</param>
/// <param name="ignoreCase">대소문자 무시 여부</param>
/// <returns></returns>
public static RadTreeNode FirstOrDefaultByValue(this IRadTreeNodeContainer nodeContainer, string nodeValue, bool ignoreCase = true)
{
if (nodeContainer == null)
{
return(null);
}
if (IsDebugEnabled)
{
log.Debug(@"특정 nodeContainer 및 자손 TreeNode 중에 Value 속성 값이 [{0}] 인 TreeNode를 찾습니다... ignoreCase=[{1}]", nodeValue, ignoreCase);
}
return(nodeContainer.FindNodes(n => string.Compare(n.Value, nodeValue, ignoreCase) == 0).FirstOrDefault());
}
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
User user = GetUser();
if (user == null || user.Department == null)
{
return;
}
Department department = new Department();
XmlHelper xmlhelper = new XmlHelper();
trvChart.LoadXml(user.Department.DeparetmentChartXML);
foreach (var dep in department.GetDepartments(null))
{
Panel container = new Panel();
if (dep.ID == user.DepartmentID)
{
continue;
}
else
{
if (string.IsNullOrEmpty(dep.DeparetmentChartXML))
{
continue;
}
var xml = xmlhelper.GetElementsByString(dep.DeparetmentChartXML, "Node");
if (xml != null && xml.Count > 0)
{
var rootNode = xml[0];
string OrganizationRoleId = rootNode.Attribute("OrganizationRoleId").Value;
string name = rootNode.Attribute("Text").Value;
IRadTreeNodeContainer target = trvChart;
RadTreeNode addedNode = new RadTreeNode(name);
//if (trvChart.SelectedNode != null)
//{
// trvChart.SelectedNode.Expanded = true;
// target = trvChart.SelectedNode;
//}
addedNode.Attributes.Add("OrganizationRoleId", OrganizationRoleId);
target.Nodes.Add(addedNode);
}
}
}
}
/// <summary>
/// 遍历科目分类
/// </summary>
/// <param name="classId"></param>
/// <param name="node"></param>
/// <param name="listModel"></param>
private void RecursivelySubjectClass(Guid classId, IRadTreeNodeContainer node, IList <SubjectClassInfo> listModel, object sender)
{
IList <SubjectClassInfo> listChild = listModel.Where(w => w.ParentClassId == classId).ToList();
foreach (SubjectClassInfo item in listChild)
{
RadTreeNode treeNode = CreateNode(item.ClassName, false, item.ClassId.ToString());
if (node == null)
{
((RadTreeView)sender).Nodes.Add(treeNode);
}
else
{
node.Nodes.Add(treeNode);
}
RecursivelySubjectClass(item.ClassId, treeNode, listModel, sender);
}
}
//遍历产品分类
private void RecursivelyGoodsClass(Guid goodsClassId, IRadTreeNodeContainer node, IList <GoodsClassInfo> goodsClassList)
{
IList <GoodsClassInfo> childGoodsClassList = goodsClassList.Where(w => w.ParentClassId == goodsClassId).ToList();
foreach (GoodsClassInfo goodsClassInfo in childGoodsClassList)
{
RadTreeNode goodsClassNode = CreateNode(goodsClassInfo.ClassName, false, goodsClassInfo.ClassId.ToString());
if (node == null)
{
TVGoodsClass.Nodes.Add(goodsClassNode);
}
else
{
node.Nodes.Add(goodsClassNode);
}
RecursivelyGoodsClass(goodsClassInfo.ClassId, goodsClassNode, goodsClassList);
}
}
/// <summary>
/// 특정 TreeNode의 자식으로 노드를 추가합니다.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="parent"></param>
/// <param name="nodeFactory">노드 생성 메소드</param>
/// <param name="nodeAddedAction">노드 추가마다 호출되는 메소드</param>
/// <param name="items"></param>
public static void AddNodes <T>(this IRadTreeNodeContainer parent,
Func <T, RadTreeNode> nodeFactory,
Action <T, RadTreeNode> nodeAddedAction,
IEnumerable <T> items)
{
if (items.IsEmptySequence())
{
return;
}
parent.ShouldNotBeNull("parent");
nodeFactory.ShouldNotBeNull("nodeFactory");
if (IsDebugEnabled)
{
log.Debug(@"TreeNode의 자식 노드들을 추가합니다...");
}
foreach (T item in items)
{
if (IsDebugEnabled)
{
log.Debug(@"엔티티를 RadTreeNode로 빌드합니다. item=[{0}]", item);
}
var childNode = nodeFactory(item);
if (childNode != null)
{
parent.Nodes.Add(childNode);
if (IsDebugEnabled)
{
log.Debug(@"TreeNode에 자식 노드를 추가했습니다. parent=[{0}], childNode=[{1}]", parent, childNode.Text);
}
if (nodeAddedAction != null)
{
nodeAddedAction(item, childNode);
}
}
}
}
/// <summary>
/// 깊이 우선 탐색을 통해, 현재 Node와 Node의 자손 Node들을 열거합니다. 열거 순서에 상관없으려면 node.GetAllNodes()를 사용하세요
/// </summary>
/// <param name="nodeContainer"></param>
/// <returns></returns>
public static IEnumerable <RadTreeNode> GetDescendentNodes(this IRadTreeNodeContainer nodeContainer)
{
if (nodeContainer == null)
{
yield break;
}
if (IsDebugEnabled)
{
log.Debug(@"특정 nodeContainer의 자신과 모든 자손 노드들을 열거합니다... nodeContainer=[{0}]", nodeContainer.AsTextAndValue());
}
foreach (RadTreeNode rootNode in GetRootNodesOrSelfNode(nodeContainer))
{
foreach (var childNode in rootNode.GraphDepthFirstScan(n => n.Nodes.Cast <RadTreeNode>()))
{
yield return(childNode);
}
}
}
//遍历资金帐户
private void RecursivelyBankAccounts(IRadTreeNodeContainer node, Guid filialeId)
{
if (_reckoningElseFilialeid == filialeId)
{
var bankAccountsInfoList = _bankAccountsWrite.GetList().Where(ent => !ent.IsMain).OrderByDescending(ent => ent.IsUse).ToList();
foreach (var bankAccountsInfo in bankAccountsInfoList)
{
var childNode = CreateNode((bankAccountsInfo.IsUse ? "" : "【停用】") + bankAccountsInfo.BankName + "[" + GetBankAccountsCount(bankAccountsInfo.BankAccountsId) + "]", false, bankAccountsInfo.BankAccountsId.ToString(), "BankAccount");
node.Nodes.Add(childNode);
}
}
else
{
var bankAccountsInfoList = _bankAccountDaoRead.GetListByTargetId(filialeId).OrderByDescending(ent => ent.IsUse).ToList();
foreach (var bankAccountsInfo in bankAccountsInfoList)
{
var childNode = CreateNode(string.Format("{0}{1}[{2}]", !bankAccountsInfo.IsUse ? "【停用】" : "", bankAccountsInfo.BankName, GetBankAccountsCount(bankAccountsInfo.BankAccountsId)), false, bankAccountsInfo.BankAccountsId.ToString(), "BankAccount");
node.Nodes.Add(childNode);
}
}
}
/// <summary>
/// <see cref="nodeContainer"/>의 모든 Node에 대한 정보를 문자열로 표현하도록 합니다. 디버그 시에만 사용하세요.
/// </summary>
/// <param name="nodeContainer"></param>
/// <returns></returns>
public static string AsTextAndValue(this IRadTreeNodeContainer nodeContainer)
{
if (nodeContainer == null)
{
return(@"NULL");
}
if (nodeContainer is RadTreeNode)
{
var node = (RadTreeNode)nodeContainer;
return(string.Format(@"RadTreeNode#Text={0},Value={1}", node.Text, node.Value));
}
if (nodeContainer is RadTreeView)
{
var treeview = (RadTreeView)nodeContainer;
return(string.Format(@"RadTreeView#ID={0},ClientID={1},SelectedValue={2}", treeview.ID, treeview.ClientID, treeview.SelectedValue));
}
return(nodeContainer.ObjectToString());
}
/// <summary>
/// nodeContainer의 자신과 자손 TreeNode를 깊이 우선 탐색 방식으로 열거합니다.
/// </summary>
/// <param name="nodeContainer">기준 노드 또는 TreeView</param>
/// <returns></returns>
public static IEnumerable <RadTreeNode> GetNodesByDepthFirst(this IRadTreeNodeContainer nodeContainer)
{
if (nodeContainer == null)
{
yield break;
}
if (IsDebugEnabled)
{
log.Debug(@"특정 NodeContainer를 깊이 우선 탐색을 수행합니다. nodeContainer=[{0}]", nodeContainer.AsTextAndValue());
}
foreach (RadTreeNode root in GetRootNodesOrSelfNode(nodeContainer))
{
yield return(root);
foreach (var node in root.GraphDepthFirstScan(n => n.Nodes.Cast <RadTreeNode>()))
{
yield return(node);
}
}
}
/// <summary>
/// Render all Tabs including Child Tabs
/// </summary>
/// <param name="nodeParent">
/// Parent Node(Tab)
/// </param>
/// <param name="iParentTabId">
/// Parent Tab ID
/// </param>
private void RenderTabLevels(IRadTreeNodeContainer nodeParent, int iParentTabId)
{
foreach (TabInfo objTab in
TabController.GetPortalTabs(
this._portalSettings.PortalId, -1, false, null, true, false, true, true, false))
{
if (!objTab.ParentId.Equals(iParentTabId))
{
continue;
}
var nodeTab = new RadTreeNode();
if (nodeParent != null)
{
nodeParent.Nodes.Add(nodeTab);
}
else
{
this.dnntreeTabs.Nodes.Add(nodeTab);
}
nodeTab.Text = objTab.TabName;
nodeTab.Value = objTab.TabID.ToString();
nodeTab.ImageUrl = "Images/Page.gif";
// nodeTab.ExpandedImageUrl = "Images/folderOpen.gif";
if (!string.IsNullOrEmpty(objTab.IconFile))
{
nodeTab.ImageUrl = this.ResolveUrl(objTab.IconFile);
}
this.RenderTabLevels(nodeTab, objTab.TabID);
}
}
/// <summary> /// 현재 노드에 대한 자식 엔티티 목록을 로드하여 <see cref="Entities"/>에 할당합니다. /// </summary> /// <param name="node"></param> protected abstract void LoadEntity(IRadTreeNodeContainer node);
/// <summary>
/// 특정 TreeNode의 자식으로 노드를 추가합니다. NFramework.Data.NHibernateEx.Domain.ITreeNodeEntity를 구현한 클래스에 대해서는 BuildTreeNodes 함수를 사용하세요.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="parent"></param>
/// <param name="nodeFactory"></param>
/// <param name="items"></param>
public static void AddNodes <T>(this IRadTreeNodeContainer parent, Func <T, RadTreeNode> nodeFactory, IEnumerable <T> items)
{
AddNodes <T>(parent, nodeFactory, null, items);
}
//遍历资金帐户
private bool RecursivelyBankAccounts(IRadTreeNodeContainer node, Guid targetId)
{
var flag = true;
var personnelInfo = CurrentSession.Personnel.Get();
if (personnelInfo != null)
{
var selectSalePlatformInfo = CacheCollection.SalePlatform.Get(targetId);
IEnumerable <BankAccountInfo> infos = _bankAccountsDao.GetListByTargetId(targetId);
if (infos != null && infos.Any())
{
if (selectSalePlatformInfo == null)
{
IList <BankAccountInfo> bankAccountList =
_bankAccounts.GetBankAccountsList(personnelInfo.FilialeId, personnelInfo.BranchId, personnelInfo.PositionId)
.Where(b => infos.Any(ent => ent.BankAccountsId == b.BankAccountsId) && b.IsUse)
.OrderByDescending(b => b.IsUse)
.ToList();
var salePlatformList = CacheCollection.SalePlatform.GetListByFilialeId(targetId);
var bindingedBankAccountList = new List <BankAccountInfo>();
foreach (var salePlatformInfo in salePlatformList.Where(act => act.IsActive))
{
bindingedBankAccountList.AddRange(_bankAccountsDao.GetListByTargetId(salePlatformInfo.ID));
}
var needBankAccountList = (from item in bankAccountList
where
bindingedBankAccountList.All(
ent => ent.BankAccountsId != item.BankAccountsId)
select new BankAccountInfo
{
BankAccountsId = item.BankAccountsId,
Accounts = item.Accounts,
AccountsKey = item.AccountsKey,
AccountsName = item.AccountsName,
BankIcon = item.BankIcon,
BankName = item.BankName,
Description = item.Description,
IsFinish = item.IsFinish,
IsUse = item.IsUse,
OrderIndex = item.OrderIndex,
PaymentInterfaceId = item.PaymentInterfaceId,
PaymentType = item.PaymentType,
}).ToList();
flag = needBankAccountList.Count > 0;
foreach (var bankAccountsInfo in needBankAccountList)
{
var childNode =
CreateNode(
(bankAccountsInfo.IsUse ? "" : "【停用】") + bankAccountsInfo.BankName + " - " + bankAccountsInfo.AccountsName + "[" +
GetBankAccountsCount(bankAccountsInfo.BankAccountsId).ToString("N") + "]", false,
bankAccountsInfo.BankAccountsId.ToString(), "BankAccount");
node.Nodes.Add(childNode);
}
}
else
{
if (selectSalePlatformInfo.IsActive)
{
IList <BankAccountInfo> bankAccountsInfoList =
_bankAccounts.GetBankAccountsList(personnelInfo.FilialeId, personnelInfo.BranchId, personnelInfo.PositionId)
.Where(b => infos.Any(ent => ent.BankAccountsId == b.BankAccountsId) && b.IsUse)
.OrderByDescending(b => b.IsUse)
.ToList();
flag = bankAccountsInfoList.Count > 0;
foreach (var bankAccountsInfo in bankAccountsInfoList)
{
var childNode =
CreateNode(
(bankAccountsInfo.IsUse ? "" : "【停用】") + bankAccountsInfo.BankName + " - " + bankAccountsInfo.AccountsName + "[" +
GetBankAccountsCount(bankAccountsInfo.BankAccountsId).ToString("N") + "]", false,
bankAccountsInfo.BankAccountsId.ToString(), "BankAccount");
node.Nodes.Add(childNode);
}
}
else
{
flag = false;
}
}
}
}
return(flag);
}
/// <summary>
/// <see cref="ITreeNodeEntity{T}"/>를 구현한 엔티티들을 표현할 TreeNode를 생성하여 TreeView에 추가합니다.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="parent">부모 노드 또는 TreeView</param>
/// <param name="nodeFactory">TreeNode를 생성하는 Factory 함수</param>
/// <param name="findNodeFunc">기존 TreeView에서 엔티티와 관련된 Node를 찾는 함수</param>
/// <param name="nodeAddedAction">TreeNode 하나를 추가할 때마다 수행하는 Action</param>
/// <param name="items">엔티티</param>
/// <param name="includeChildren">엔티티의 자손들도 Binding 할 것인가?</param>
public static void BuildTreeNodes <T>(this IRadTreeNodeContainer parent,
Func <T, RadTreeNode> nodeFactory,
Func <T, RadTreeNode> findNodeFunc,
Action <T, RadTreeNode> nodeAddedAction,
IEnumerable <T> items,
bool includeChildren) where T : class, ITreeNodeEntity <T>
{
if (items.IsEmptySequence())
{
return;
}
parent.ShouldNotBeNull("parent");
nodeFactory.ShouldNotBeNull("nodeFactory");
findNodeFunc.ShouldNotBeNull("findNodeFunc");
RadTreeNode parentNode = null;
foreach (T item in items)
{
// 이미 관련 노드가 있다면 추가하지 않습니다.
if (findNodeFunc(item) != null)
{
continue;
}
if (IsDebugEnabled)
{
log.Debug(@"엔티티를 TreeNode로 빌드하여, TreeView에 추가합니다... item=[{0}]", item);
}
var childNode = nodeFactory(item);
if (item.Parent != null)
{
parentNode = findNodeFunc(item.Parent);
}
if (parentNode != null)
{
// 부모 노드가 이미 TreeView에 추가되어 있다면, 부모 노드에 자식으로 추가합니다.
parentNode.Nodes.Add(childNode);
}
else
{
// 부모 노드가 없다면, parent에 추가한다.
parent.Nodes.Add(childNode);
}
if (IsDebugEnabled)
{
log.Debug(@"엔티티를 TreeNode로 빌드하여, TreeView에 추가했습니다!!!. childNode=[{0}]", childNode);
}
if (nodeAddedAction != null)
{
nodeAddedAction(item, childNode);
}
// 자식 노드들이 있고, 추가해야 한다면 DepthFirst 방식으로 추가합니다.
//
if (includeChildren && item.GetChildCount() > 0)
{
BuildTreeNodes(parentNode ?? parent, nodeFactory, findNodeFunc, nodeAddedAction, item.Children, true);
}
}
}
