#region

using System;
using System.Data;
using CSFrameworkV5.Business;
using CSFrameworkV5.Business.BLL_Permission;
using CSFrameworkV5.Common;
using CSFrameworkV5.Core;
using CSFrameworkV5.Library.CommonClass;
using CSFrameworkV5.Models;
using DevExpress.XtraTab;
using DevExpress.XtraTreeList;
using DevExpress.XtraTreeList.Nodes;

#endregion

namespace CSFrameworkV5.Library.PermissionForms
{
    public partial class frmGroupLevel : frmBase
    {
        private DataTable _AllGroup; //所有组数据
        private DataTable _AllRole; //所有角色
        private DataTable _AllUser; //所有用户
        private bllGroup _BLL;
        private GroupRoleCache _GroupRoleCache;

        private GroupUserCache _GroupUserCache;

        private bool _SaveOK; //只要1次保存成功，表示已修改数据

        public frmGroupLevel()
        {
            InitializeComponent();
        }

        private void tc_SelectedPageChanged(object sender,
            TabPageChangedEventArgs e)
        {
            if (e.Page == xtraTabPage1)
                DevTreeListView.SetImageIndex(tlGroup4User, null, 1, 0);

            if (e.Page == xtraTabPage2)
                DevTreeListView.SetImageIndex(tlGroup4Role, null, 1, 0);
        }

        #region 公共方法

        public static bool ExecuteOrgUser()
        {
            var form = new frmGroupLevel();
            form.xtraTabPage2.PageVisible = false;
            form.Text = "批量设置组织机构的用户";
            form.ShowDialog();
            return form._SaveOK;
        }

        private void frmGroupLevel_Load(object sender, EventArgs e)
        {
            _BLL = new bllGroup();

            _AllGroup = new bllGroup().GetLookupData();
            _AllUser = new bllUser().GetLookupData();
            _AllRole = new bllRole().GetLookupData();

            _GroupUserCache = new GroupUserCache();
            _GroupUserCache.LoadData();

            _GroupRoleCache = new GroupRoleCache();
            _GroupRoleCache.LoadData();

            DevStyle.SetTreeListSelectStyle(tlGroup4Role);
            DevStyle.SetTreeListSelectStyle(tlGroup4User);

            InitTreeList(tlGroup4User, _AllGroup.Copy());
            InitTreeList(tlGroup4Role, _AllGroup.Copy());

            InitUser(_AllUser);
            InitRole(_AllRole);
        }

        /// <summary>
        ///     初始化组织结构树
        /// </summary>
        /// <param name="tree"></param>
        /// <param name="treeData"></param>
        private void InitTreeList(TreeList tree, DataTable treeData)
        {
            DataTableTools.AddMergedColumn(treeData, "Union",
                tb_MyGroup.GroupName, tb_MyGroup.GroupCode);

            tree.KeyFieldName = tb_MyGroup.GroupCode; //设置主键 
            tree.ParentFieldName = tb_MyGroup.ParentGroupCode; //设置父级主键 
            tree.RootValue = ""; //顶级树结点的值 
            tree.BeginUpdate();
            tree.DataSource = treeData;
            DevTreeListView.SetImageIndex(tree, null, 1, 0);
            tree.EndUpdate();
            tree.ExpandAll();
        }

        private void btnClose_Click(object sender, EventArgs e)
        {
            Close();
        }

        private void btnSave_Click(object sender, EventArgs e)
        {
            if (Msg.AskQuestion("确定要保存吗?")) DoSave();
        }

        /// <summary>
        ///     保存数据
        /// </summary>
        private void DoSave()
        {
            try
            {
                frmWaitingEx.ShowMe(this);

                var dtGroupUser = _GroupUserCache.GetChanges();
                var dtGroupRole = _GroupRoleCache.GetChanges();

                var ds = new DataSet();
                if (dtGroupUser != null) ds.Tables.Add(dtGroupUser);

                if (dtGroupRole != null) ds.Tables.Add(dtGroupRole);

                if (ds.Tables.Count > 0)
                {
                    _SaveOK = _SaveOK || _BLL.Update(ds);

                    if (dtGroupUser != null) _GroupUserCache.LoadData(); //刷新数据

                    if (dtGroupRole != null) _GroupRoleCache.LoadData(); //刷新数据

                    Msg.ShowInformation("保存成功！");
                }
                else
                {
                    Msg.Warning("您没有修改数据！");
                }
            }
            finally
            {
                frmWaitingEx.HideMe(this);
            }
        }

        #endregion

        #region 批量设置组织机构的用户

        /// <summary>
        ///     加载用户列表
        /// </summary>
        /// <param name="dtUser"></param>
        private void InitUser(DataTable dtUser)
        {
            SetUserImageIndex(dtUser);
            lbAllUser.Items.Clear();

            DataTableTools.AddMergedColumn(dtUser, "Union", tb_MyUser.UserName,
                tb_MyUser.Account);

            lbAllUser.DisplayMember = "Union";
            lbAllUser.ValueMember = tb_MyUser.Account;
            lbAllUser.DataSource = dtUser;
            lbAllUser.Invalidate();
        }

        /// <summary>
        ///     设置用户的图标，该用户属于某个组，显示勾选图标，反之，显示灰色图标
        /// </summary>
        /// <param name="dtUser">所有用户数据</param>
        private void SetUserImageIndex(DataTable dtUser)
        {
            lbAllUser.ImageIndexMember = "ImageIndex";
            if (dtUser.Columns["ImageIndex"] == null)
                dtUser.Columns.Add("ImageIndex", typeof(int));

            bool exists;
            foreach (DataRow R in dtUser.Rows)
            {
                exists = _GroupUserCache.HasGroup(R["Account"].ToStringEx());
                if (exists)
                    R["ImageIndex"] = 1;
                else
                    R["ImageIndex"] = 0;
            }

            dtUser.AcceptChanges();
        }

        private void btnFindUser_Click(object sender, EventArgs e)
        {
            if (_AllUser != null && txtUserText.Text.Trim() != "")
            {
                var dt = _AllUser.Copy();
                dt.DefaultView.RowFilter =
                    "Account LIKE '%" + txtUserText.Text +
                    "%' OR UserName LIKE '%" +
                    txtUserText.Text + "%'";
                InitUser(dt.DefaultView.ToTable());
            }
        }

        /// <summary>
        ///     节点的勾选状态发生变化
        /// </summary>
        /// <param name="node"></param>
        private void UpdateByNodeDataUser(TreeListNode node)
        {
            if (lbAllUser.SelectedItem == null) return;

            var R = (lbAllUser.SelectedItem as DataRowView)
                .Row; //当前用户            
            var account = R[tb_MyUser.Account].ToStringEx(); //取出当前用户

            //修改结点后，显示图标状态
            var list = tlGroup4User.GetAllCheckedNodes();
            R["ImageIndex"] = list.Count > 0 ? 1 : 0;

            _GroupUserCache.UpdateByNodeCheckChild(account, node, node.Checked);
        }

        private void lbAllUser_SelectedIndexChanged(object sender, EventArgs e)
        {
            //选择用户，勾选存在的组
            if (lbAllUser.SelectedIndex >= 0)
            {
                var DV = lbAllUser.SelectedItem as DataRowView;
                var account = DV.Row[tb_MyUser.Account].ToStringEx();
                SetGroupCheckedByUser(account);
            }
        }

        private void txtUserText_EditValueChanged(object sender, EventArgs e)
        {
            //清空查询条件，显示所有用户
            if (txtUserText.Text.Trim() == "") InitUser(_AllUser);
        }

        private void tlGroup4User_AfterCheckNode(object sender, NodeEventArgs e)
        {
            UpdateByNodeDataUser(e.Node);
        }

        /// <summary>
        ///     获取用户的组数据，在组织结构中勾选存在的组
        /// </summary>
        /// <param name="account"></param>
        private void SetGroupCheckedByUser(string account)
        {
            var dt = _GroupUserCache.GetGroupsByUser(account);
            tlGroup4User.UncheckAll();
            foreach (DataRow R in dt.Rows)
            {
                var group = R[tb_MyGroup.GroupCode].ToStringEx();
                var N = tlGroup4User.FindNodeByKeyID(group);
                if (N != null)
                {
                    N.Checked = true;
                    N.ExpandAll();
                }
            }
        }

        #endregion

        #region 批量设置组织机构的角色

        /// <summary>
        ///     加载角色列表
        /// </summary>
        /// <param name="dtRole"></param>
        private void InitRole(DataTable dtRole)
        {
            SetRoleImageIndex(dtRole);
            lbAllRole.Items.Clear();

            DataTableTools.AddMergedColumn(dtRole, "Union", tb_MyRole.RoleName,
                tb_MyRole.RoleID);

            lbAllRole.DisplayMember = "Union";
            lbAllRole.ValueMember = tb_MyRole.RoleID;
            lbAllRole.DataSource = dtRole;
            lbAllRole.Invalidate();
        }

        /// <summary>
        ///     设置角色的图标，该角色属于某个组，显示勾选图标，反之，显示灰色图标
        /// </summary>
        /// <param name="dtRole">所有角色数据</param>
        private void SetRoleImageIndex(DataTable dtRole)
        {
            lbAllRole.ImageIndexMember = "ImageIndex";
            if (dtRole.Columns["ImageIndex"] == null)
                dtRole.Columns.Add("ImageIndex", typeof(int));

            bool exists;
            foreach (DataRow R in dtRole.Rows)
            {
                exists =
                    _GroupRoleCache.HasGroup(R[tb_MyRole.RoleID].ToStringEx());
                if (exists)
                    R["ImageIndex"] = 1;
                else
                    R["ImageIndex"] = 0;
            }

            dtRole.AcceptChanges();
        }

        private void btnFindRole_Click(object sender, EventArgs e)
        {
            if (_AllRole != null && txtRoleText.Text.Trim() != "")
            {
                var dt = _AllRole.Copy();
                dt.DefaultView.RowFilter =
                    "RoleID LIKE '%" + txtRoleText.Text +
                    "%' OR RoleName LIKE '%" +
                    txtRoleText.Text + "%'";
                InitRole(dt.DefaultView.ToTable());
            }
        }

        /// <summary>
        ///     节点的勾选状态发生变化
        /// </summary>
        /// <param name="node"></param>
        private void UpdateByNodeDataRole(TreeListNode node)
        {
            if (lbAllRole.SelectedItem == null) return;

            var R = (lbAllRole.SelectedItem as DataRowView)
                .Row; //当前用户            
            var roleID = R[tb_MyRole.RoleID].ToStringEx(); //取出当前角色

            //修改结点后，显示图标状态
            var list = tlGroup4Role.GetAllCheckedNodes();
            R["ImageIndex"] = list.Count > 0 ? 1 : 0;

            _GroupRoleCache.UpdateByNodeCheckChild(roleID, node, node.Checked);
        }

        private void lbAllRole_SelectedIndexChanged(object sender, EventArgs e)
        {
            //选择用户，勾选存在的组
            if (lbAllRole.SelectedIndex >= 0)
            {
                var DV = lbAllRole.SelectedItem as DataRowView;
                var roleID = DV.Row[tb_MyRole.RoleID].ToStringEx();
                SetGroupCheckedByRole(roleID);
            }
        }

        private void txtRoleText_EditValueChanged(object sender, EventArgs e)
        {
            //清空查询条件，显示所有用户
            if (txtRoleText.Text.Trim() == "") InitRole(_AllRole);
        }

        private void tlGroup4Role_AfterCheckNode(object sender, NodeEventArgs e)
        {
            UpdateByNodeDataRole(e.Node);
        }

        /// <summary>
        ///     获取用户的组数据，在组织结构中勾选存在的组
        /// </summary>
        /// <param name="roleID"></param>
        private void SetGroupCheckedByRole(string roleID)
        {
            var dt = _GroupRoleCache.GetGroupsByRole(roleID);
            tlGroup4Role.UncheckAll();
            foreach (DataRow R in dt.Rows)
            {
                var group = R[tb_MyGroup.GroupCode].ToStringEx();
                var N = tlGroup4Role.FindNodeByKeyID(group);
                if (N != null)
                {
                    N.Checked = true;
                    N.ExpandAll();
                }
            }
        }

        #endregion
    }

    /// <summary>
    ///     组用户表(tb_MyGroupUser)动态数据，处理组织机构树勾选状态对应的数据
    /// </summary>
    public class GroupUserCache
    {
        private bllGroup _BLL; //业务逻辑层
        private DataTable _GroupUserData; //所有组用户关系表的数据(tb_MyGroupUser表)
        private DataTable _GroupUserData4Tree; //动态数据,勾选状态对应的数据

        public GroupUserCache()
        {
            _BLL = new bllGroup();
        }

        /// <summary>
        ///     获取用于保存的数据
        /// </summary>
        /// <returns></returns>
        public DataTable GetChanges()
        {
            var dtSave = _GroupUserData.Copy(); //复制所有数据
            DataRow[] rs;
            string groupCode;
            string account;
            var filter = "Account='{0}' AND GroupCode='{1}'";

            //收集删除的记录,枚举所有组的用户数据，
            foreach (DataRow R in dtSave.Rows)
            {
                account = R[tb_MyGroupUser.Account].ToStringEx();
                groupCode = R[tb_MyGroupUser.GroupCode].ToStringEx();
                rs = _GroupUserData4Tree.Select(string.Format(filter, account,
                    groupCode));
                if (rs.Length == 0) //副本数据不存在，表示已删除,打上删除标记
                    R.Delete();
            }

            //收集新增记录
            foreach (DataRow R in _GroupUserData4Tree.Rows)
            {
                account = R[tb_MyGroupUser.Account].ToStringEx();
                groupCode = R[tb_MyGroupUser.GroupCode].ToStringEx();
                rs = _GroupUserData.Select(string.Format(filter, account,
                    groupCode));
                if (rs.Length == 0) //原始数据不存在，新增记录
                    dtSave.Rows.Add(R.ItemArray);
            }

            return dtSave.GetChanges();
        }

        /// <summary>
        ///     取用户的组
        /// </summary>
        /// <param name="account"></param>
        /// <returns></returns>
        public DataTable GetGroupsByUser(string account)
        {
            _GroupUserData4Tree.DefaultView.RowFilter =
                "Account='" + account + "'";
            return _GroupUserData4Tree.DefaultView.ToTable();
        }

        /// <summary>
        ///     判断用户是否属于组
        /// </summary>
        /// <param name="user"></param>
        /// <returns></returns>
        public bool HasGroup(string user)
        {
            var rs = _GroupUserData4Tree.Select("Account='" + user + "'");
            return rs.Length > 0;
        }

        /// <summary>
        ///     加载tb_MyGroupUser数据
        /// </summary>
        public void LoadData()
        {
            _GroupUserData = CommonData.GetDataDict(Globals.DEF_SYSTEM_DBID,
                tb_MyGroupUser.__TableName);
            _GroupUserData4Tree = _GroupUserData.Copy();
        }

        /// <summary>
        ///     Node.Check事件后，更新数据源
        /// </summary>
        /// <param name="account"></param>
        /// <param name="groupCode"></param>
        /// <param name="isCheck"></param>
        public void UpdateByNodeCheck(string account, string groupCode,
            bool isCheck)
        {
            var filter = string.Format("Account='{0}' AND GroupCode='{1}'",
                account, groupCode);
            var rs = _GroupUserData4Tree.Select(filter);
            if (isCheck && rs.Length == 0) //勾选,数据源不存在，新增
            {
                var newRow = _GroupUserData4Tree.Rows.Add();
                newRow[tb_MyGroupUser.DataSetID] = Loginer.CurrentUser.DBID;
                newRow[tb_MyGroupUser.Account] = account;
                newRow[tb_MyGroupUser.GroupCode] = groupCode;
            }

            if (!isCheck && rs.Length > 0) //不勾选，数据源存在数据，删除
                _GroupUserData4Tree.Rows.Remove(rs[0]);
        }

        /// <summary>
        ///     勾选当前结点，子节点要全勾上
        /// </summary>
        /// <param name="account">当前用户</param>
        /// <param name="node">当前结点</param>
        /// <param name="isChecked">结点的勾选状态</param>
        public void UpdateByNodeCheckChild(string account, TreeListNode node,
            bool isChecked)
        {
            node.Checked = isChecked;

            var groupCode =
                node.GetValue(tb_MyGroup.GroupCode).ToStringEx(); //取出当前结点的组号

            //新增、删除组用户记录
            UpdateByNodeCheck(account, groupCode, isChecked); //当前结点

            //处理子节点
            foreach (TreeListNode N in node.Nodes)
                UpdateByNodeCheckChild(account, N, isChecked);
        }
    }

    /// <summary>
    ///     组角色表(tb_MyGroupRole)动态数据，处理组织机构树勾选状态对应的数据
    /// </summary>
    public class GroupRoleCache
    {
        private bllGroup _BLL; //业务逻辑层
        private DataTable _GroupRoleData; //所有组角色关系表的数据(tb_MyGroupRole表)
        private DataTable _GroupRoleData4Tree; //动态数据,勾选状态对应的数据

        public GroupRoleCache()
        {
            _BLL = new bllGroup();
        }

        /// <summary>
        ///     获取用于保存的数据
        /// </summary>
        /// <returns></returns>
        public DataTable GetChanges()
        {
            var dtSave = _GroupRoleData.Copy(); //复制所有数据
            DataRow[] rs;
            string groupCode;
            string roleID;
            var filter = "RoleID='{0}' AND GroupCode='{1}'";

            //收集删除的记录,枚举所有组的角色数据，
            foreach (DataRow R in dtSave.Rows)
            {
                roleID = R[tb_MyGroupRole.RoleID].ToStringEx();
                groupCode = R[tb_MyGroupRole.GroupCode].ToStringEx();
                rs = _GroupRoleData4Tree.Select(string.Format(filter, roleID,
                    groupCode));
                if (rs.Length == 0) //副本数据不存在，表示已删除,打上删除标记
                    R.Delete();
            }

            //收集新增记录
            foreach (DataRow R in _GroupRoleData4Tree.Rows)
            {
                roleID = R[tb_MyGroupRole.RoleID].ToStringEx();
                groupCode = R[tb_MyGroupRole.GroupCode].ToStringEx();
                rs = _GroupRoleData.Select(string.Format(filter, roleID,
                    groupCode));
                if (rs.Length == 0) //原始数据不存在，新增记录
                    dtSave.Rows.Add(R.ItemArray);
            }

            return dtSave.GetChanges();
        }

        /// <summary>
        ///     取角色所属于的组
        /// </summary>
        /// <param name="roleID"></param>
        /// <returns></returns>
        public DataTable GetGroupsByRole(string roleID)
        {
            _GroupRoleData4Tree.DefaultView.RowFilter =
                "RoleID='" + roleID + "'";
            return _GroupRoleData4Tree.DefaultView.ToTable();
        }

        /// <summary>
        ///     判断角色是否属于组
        /// </summary>
        /// <param name="user"></param>
        /// <returns></returns>
        public bool HasGroup(string roleID)
        {
            var rs = _GroupRoleData4Tree.Select("RoleID='" + roleID + "'");
            return rs.Length > 0;
        }

        /// <summary>
        ///     加载tb_MyGroupRole数据
        /// </summary>
        public void LoadData()
        {
            _GroupRoleData = CommonData.GetDataDict(Globals.DEF_SYSTEM_DBID,
                tb_MyGroupRole.__TableName);
            _GroupRoleData4Tree = _GroupRoleData.Copy();
        }

        /// <summary>
        ///     Node.Check事件后，更新数据源
        /// </summary>
        /// <param name="roleID"></param>
        /// <param name="groupCode"></param>
        /// <param name="isCheck"></param>
        public void UpdateByNodeCheck(string roleID, string groupCode,
            bool isCheck)
        {
            var filter = string.Format("RoleID='{0}' AND GroupCode='{1}'",
                roleID, groupCode);
            var rs = _GroupRoleData4Tree.Select(filter);
            if (isCheck && rs.Length == 0) //勾选,数据源不存在，新增
            {
                var newRow = _GroupRoleData4Tree.Rows.Add();
                newRow[tb_MyGroupRole.DataSetID] = Loginer.CurrentUser.DBID;
                newRow[tb_MyGroupRole.RoleID] = roleID;
                newRow[tb_MyGroupRole.GroupCode] = groupCode;
            }

            if (!isCheck && rs.Length > 0) //不勾选，数据源存在数据，删除
                _GroupRoleData4Tree.Rows.Remove(rs[0]);
        }

        /// <summary>
        ///     勾选当前结点，子节点要全勾上
        /// </summary>
        /// <param name="roleID">当前用户</param>
        /// <param name="node">当前结点</param>
        /// <param name="isChecked">结点的勾选状态</param>
        public void UpdateByNodeCheckChild(string roleID, TreeListNode node,
            bool isChecked)
        {
            node.Checked = isChecked;

            var groupCode =
                node.GetValue(tb_MyGroup.GroupCode).ToStringEx(); //取出当前结点的组号

            //新增、删除组的角色记录
            UpdateByNodeCheck(roleID, groupCode, isChecked); //当前结点

            //处理子节点
            foreach (TreeListNode N in node.Nodes)
                UpdateByNodeCheckChild(roleID, N, isChecked);
        }
    }
}