using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using WMS.Frm.Base;
using WMS.Model.Base;
using WMS.Model.SystemManage;
using WMS.Common;
using DevExpress.XtraTreeList.Nodes;
using WMS.Ctrl;
using DevExpress.XtraGrid.Columns;
using DevExpress.XtraEditors.Repository;
using System.Threading;
using WMS.Business.SystemManage;
using WMS.Model.Stock;
using WMS.Business;
using WMS.Business.Base;

namespace WMS.FrmSystems
{
    /// <summary>
    /// 权限管理
    /// </summary>
    public partial class FrmRole : FormBase
    {
        #region 变量
        BussSysRole bussSysRole = new BussSysRole();
        /// <summary>
        /// 角色信息集合
        /// </summary>
        List<RoleModel> listRoleModel = new List<RoleModel>();
        /// <summary>
        /// 角色信息
        /// </summary>
        RoleModel roleModel = new RoleModel();
        /// <summary>
        /// 用户信息集合
        /// </summary>
        List<UserDataModel> listUser = new List<UserDataModel>();


        /// <summary>
        /// 菜单集合
        /// </summary>
        List<BaseMenuModel> listMenu = new List<BaseMenuModel>();
        /// <summary>
        /// 菜单权限Model
        /// </summary>
        MenuRoleModel roleMenu = new MenuRoleModel();
        /// <summary>
        /// 菜单权限集合
        /// </summary>
        List<MenuRoleModel> listMenuRole = new List<MenuRoleModel>();
        /// <summary>
        /// 菜单权限增加集合
        /// </summary>
        List<MenuRoleModel> listMenuRoleAdd = new List<MenuRoleModel>();
        /// <summary>
        /// 菜单权限删除集合
        /// </summary>
        List<MenuRoleModel> listMenuRoleDel = new List<MenuRoleModel>();


        /// <summary>
        /// 功能集合
        /// </summary>
        List<MenuFuctionModel> listFuction = new List<MenuFuctionModel>();
        /// <summary>
        /// 功能权限Model
        /// </summary>
        FunctionRoleModel roleFuction = new FunctionRoleModel();
        /// <summary>
        /// 功能权限集合
        /// </summary>
        List<FunctionRoleModel> listFuctionRole = new List<FunctionRoleModel>();
        /// <summary>
        /// 功能权限增加集合
        /// </summary>
        List<FunctionRoleModel> listFuctionRoleAdd = new List<FunctionRoleModel>();
        /// <summary>
        /// 功能权限删除集合
        /// </summary>
        List<FunctionRoleModel> listFuctionRoleDel = new List<FunctionRoleModel>();


        /// <summary>
        /// 商品分类集合
        /// </summary>
        List<GoodsTypeModel> listGoodsType = new List<GoodsTypeModel>();
        /// <summary>
        /// 商品权限Model
        /// </summary>
        GoodsRoleModel roleGoodsType = new GoodsRoleModel();
        /// <summary>
        /// 商品权限集合
        /// </summary>
        List<GoodsRoleModel> listGoodsTypeRole = new List<GoodsRoleModel>();
        /// <summary>
        /// 商品权限增加集合
        /// </summary>
        List<GoodsRoleModel> listGoodsTypeRoleAdd = new List<GoodsRoleModel>();
        /// <summary>
        /// 商品权限删除集合
        /// </summary>
        List<GoodsRoleModel> listGoodsTypeRoleDel = new List<GoodsRoleModel>();


        /// <summary>
        /// 组织机构集合
        /// </summary>
        List<CompanyModel> listCompany = new List<CompanyModel>();
        /// <summary>
        /// 组织机构权限Model
        /// </summary>
        RoleDepartModel roleDepart = new RoleDepartModel();
        /// <summary>
        /// 组织机构权限集合
        /// </summary>
        List<RoleDepartModel> listDepartRole = new List<RoleDepartModel>();
        /// <summary>
        /// 组织机构权限增加集合
        /// </summary>
        List<RoleDepartModel> listDepartRoleAdd = new List<RoleDepartModel>();
        /// <summary>
        /// 组织机构权限删除集合
        /// </summary>
        List<RoleDepartModel> listDepartRoleDel = new List<RoleDepartModel>();


        /// <summary>
        /// 供应商权限集合
        /// </summary>
        List<ProviderRoleModel> listProviderRole = new List<ProviderRoleModel>();
        /// <summary>
        /// 供应商权限增加集合
        /// </summary>
        List<ProviderRoleModel> listProviderRoleAdd = new List<ProviderRoleModel>();
        /// <summary>
        /// 供应商权限删除集合
        /// </summary>
        List<ProviderRoleModel> listProviderRoleDel = new List<ProviderRoleModel>();
        /// <summary>
        /// 供应商集合
        /// </summary>
        List<ProviderModel> listProvider = new List<ProviderModel>();
        /// <summary>
        /// 供应商权限Model
        /// </summary>
        ProviderRoleModel roleProvider = new ProviderRoleModel();

        /// <summary>
        /// 消息类型权限集合
        /// </summary>
        List<RoleMessageModel> listRoleMessage = new List<RoleMessageModel>();
        /// <summary>
        /// 消息类型Model
        /// </summary>
        RoleMessageModel roleMessage = new RoleMessageModel();

        ///// <summary>
        ///// 仓库权限集合
        ///// </summary>
        //List<RoleStorageModel> listRoleStorage = new List<RoleStorageModel>();
        ///// <summary>
        ///// 仓库权限增加集合
        ///// </summary>
        //List<RoleStorageModel> listRoleStorageAdd = new List<RoleStorageModel>();
        ///// <summary>
        ///// 仓库权限删除集合
        ///// </summary>
        //List<RoleStorageModel> listRoleStorageDel = new List<RoleStorageModel>();
        ///// <summary>
        ///// 仓库集合
        ///// </summary>
        //List<StorageInfoModel> listStorage = new List<StorageInfoModel>();
        ///// <summary>
        ///// 仓库权限Model
        ///// </summary>
        //RoleStorageModel roleStorage = new RoleStorageModel();



        /// <summary>
        /// 错误信息
        /// </summary>
        string errText = string.Empty;
        /// <summary>
        /// 点击按钮标记
        /// </summary>
        int flag = -1;

        /// <summary>
        /// 全选判断
        /// </summary>
        bool m_status = false;

        //bool load = true;

        #endregion

        #region 构造函数
        public FrmRole()
        {
            InitializeComponent();
        }
        #endregion

        #region 窗体加载
        /// <summary>
        /// 窗体加载
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FrmRole_Load(object sender, EventArgs e)
        {
            Refresh();
        }


        #endregion

        #region 数据加载
        /// <summary>
        /// 加载权限信息
        /// </summary>
        private void DataLoadRole()
        {
            try
            {

                listRoleModel = bussSysRole.GetRole("");
                bgsRole.DataSource = listRoleModel;
                if (listRoleModel.Count > 0)
                {
                    roleModel = listRoleModel[0];
                    bgsSelect.DataSource = roleModel;
                    DataLoadRoleMenu(roleModel.ROLE_ID);
                    DataLoadRoleMenuFuc(roleModel.ROLE_ID);
                }

            }
            catch (Exception ex)
            {
                string errMsg = ex.Message;

                SystemCommon.ShowErrorMessageBox("加载失败,请重试!");
            }

        }

        /// <summary>
        /// 获取角色对应的用户信息
        /// </summary>
        /// <param name="strRoleId">角色编号</param>
        /// <returns></returns>
        private void DataLoadRoleUser(string strRoleId)
        {
            try
            {
                listUser = IBussFactory<BussSysRole>.Instance().GetRoleUser(strRoleId);
                bgsUser.DataSource = listUser;
                GvUser.RefreshData();
            }
            catch
            {
                SystemCommon.ShowErrorMessageBox("加载失败,请重试!");
            }
        }

        /// <summary>
        /// 获取角色对象的菜单功能操作
        /// </summary>
        /// <param name="strRoleId">角色编号</param>
        /// <param name="strMenuId">菜单编号</param>
        /// <returns></returns>
        private void DataLoadRoleMenuFuc(string strRoleId, string strMenuId)
        {
            List<MenuFuctionModel> Fuc = listFuction.FindAll(r => r.MENU_ID == strMenuId);
            if (listFuctionRole != null)
            {
                List<FunctionRoleModel> FucRole = listFuctionRole.FindAll(r => r.MENU_ID == strMenuId);

                List<MenuFuctionModel> list = new List<MenuFuctionModel>();
                Fuc.FindAll(delegate (MenuFuctionModel target)
                {
                    foreach (FunctionRoleModel mod in FucRole)
                    {
                        if (target.FUN_ID == mod.FUN_ID)
                        {
                            list.Add(target);
                        }
                    }
                    return true;
                });
                foreach (MenuFuctionModel model in list)
                {
                    model.IsCheckRec = true;
                }
            }

            GCFuc.DataSource = Fuc;
            GVFuc.RefreshData();
            GVFuc.ExpandGroupLevel(0, true);
        }
        /// <summary>
        /// 获取角色对象的菜单功能操作
        /// </summary>
        /// <param name="strRoleId">角色编号</param>
        /// <returns></returns>
        private void DataLoadRoleMenuFuc(string strRoleId)
        {
            try
            {
                roleFuction.ROLE_ID = strRoleId;
                listFuctionRole = IBussFactory<BussFunctionRole>.Instance().GetList(roleFuction);
                MenuFuctionModel model = new MenuFuctionModel();
                listFuction = IBussFactory<WMS.Business.Base.BussSystemMenuFuc>.Instance().GetMenuDataFuc(model);
            }
            catch
            {
                SystemCommon.ShowErrorMessageBox("加载失败,请重试!");
            }
        }
        /// <summary>
        /// 获取角色对象的菜单操作
        /// </summary>
        /// <param name="strRoleId">角色编号</param>
        /// <returns></returns>
        private void DataLoadRoleMenu(string strRoleId)
        {
            try
            {
                roleMenu.ROLE_ID = strRoleId;

                listMenu = IBussFactory<BussSystemMenu>.Instance().GetMenuData(strRoleId);
                if (listMenu != null)
                {
                    #region 获得当前有权限的功能
                    listMenuRole = new List<MenuRoleModel>();
                    foreach (var item in listMenu)
                    {
                        if (item.IsCheckRec)
                        {
                            listMenuRole.Add(new MenuRoleModel()
                            {
                                ROLE_ID = strRoleId,
                                MENU_ID = item.MENU_ID

                            });
                        }
                    }
                    #endregion 

                    BSMenu.DataSource = listMenu;
                    GCMenu.ExpandAll();
                    if (GCMenu.Nodes.Count > 0)
                    {
                        GCMenu.SetFocusedNode(GCMenu.Nodes[0]);
                    }
                }

            }
            catch (Exception ex)
            {
                SystemCommon.ShowErrorMessageBox("菜单加载失败：" + ex.Message);
            }
        }
        /// <summary>
        /// 加载组织机构
        /// </summary>
        private void DataLoadDepart(string strRoleId)
        {
            //load = true;
            try
            {
                roleDepart.ROLE_ID = strRoleId;


                listDepartRole = IBussFactory<BussRoleDepart>.Instance().GetList(roleDepart);
                listCompany = IBussFactory<BussCompany>.Instance().getCompanytDataSet("", "");

                List<CompanyModel> list = new List<CompanyModel>();
                listCompany.FindAll(delegate (CompanyModel target)
                {
                    foreach (RoleDepartModel mod in listDepartRole)
                    {
                        if (target.COM_ID == mod.DEP_ID)
                        {
                            list.Add(target);
                        }
                    }
                    return true;
                });
                foreach (CompanyModel model in list)
                {
                    model.IsCheckRec = true;
                }

                TreeDepart.DataSource = listCompany;
                TreeDepart.Refresh();
                TreeDepart.ExpandAll();
            }
            catch
            {
                SystemCommon.ShowErrorMessageBox("加载失败,请重试!");
            }


        }
        /// <summary>
        /// 加载商品分类
        /// </summary>
        private void DataLoadRoleGoodsType(string strRoleId)
        {
            try
            {
                roleGoodsType.ROLE_ID = strRoleId;
                GoodsTypeModel goodsTypeModel = new GoodsTypeModel();
                listGoodsTypeRole = IBussFactory<BussGoodsRole>.Instance().GetList(roleGoodsType); ;
                listGoodsType = IBussFactory<BussGoodsType>.Instance().GetGoodsTypeList(goodsTypeModel);

                List<GoodsTypeModel> list = new List<GoodsTypeModel>();
                listGoodsType.FindAll(delegate (GoodsTypeModel target)
                {
                    foreach (GoodsRoleModel mod in listGoodsTypeRole)
                    {
                        if (target.GOODS_TYPE_ID == mod.GOODS_TYPE_ID)
                        {
                            list.Add(target);
                        }
                    }
                    return true;
                });
                foreach (GoodsTypeModel model in list)
                {
                    model.IsCheckRec = true;
                }
                treeGoodsType.DataSource = listGoodsType;
                treeGoodsType.RefreshDataSource();
                treeGoodsType.ExpandAll();
            }
            catch
            {
                SystemCommon.ShowErrorMessageBox("加载失败,请重试!");
            }
        }

        /// <summary>
        /// 加载消息类型权限数据
        /// </summary>
        /// <param name="strRoleID"></param>
        private void DataLoadMessageType(string strRoleID)
        {
            try
            {
                roleMessage.ROLE_ID = strRoleID;

                listRoleMessage = IBussFactory<BussRoleMessage>.Instance().GetRoleMessageData(roleMessage);

                if (listRoleMessage.Count > 0)
                {
                    bgsMessage.DataSource = listRoleMessage;
                    this.GVMessage.RefreshData();
                }

            }
            catch (Exception ex)
            {

            }


        }


        /// <summary>
        /// 加载供应商
        /// </summary>
        /// <param name="strRoleId"></param>
        private void DataLoadRoleProvider(string strRoleId)
        {
            try
            {
                roleProvider.ROLE_ID = strRoleId;
                ProviderModel providerModel = new ProviderModel();
                listProvider = IBussFactory<BussProvider>.Instance().GetProviderList(providerModel);
                listProviderRole = IBussFactory<BussProviderRole>.Instance().GetList(roleProvider);

                List<ProviderModel> list = new List<ProviderModel>();
                listProvider.FindAll(delegate (ProviderModel target)
                {
                    foreach (ProviderRoleModel mod in listProviderRole)
                    {
                        if (target.PROVIDER_ID == mod.PROVIDER_ID)
                        {
                            list.Add(target);
                        }
                    }
                    return true;
                });
                foreach (ProviderModel model in list)
                {
                    model.IsCheckRec = true;
                }
                GCProvider.DataSource = listProvider;
                GVProvider.RefreshData();
                GVProvider.ExpandGroupLevel(0, true);
            }
            catch
            {
                SystemCommon.ShowErrorMessageBox("加载失败,请重试!");
            }
        }

        ///// <summary>
        ///// 加载仓库
        ///// </summary>
        ///// <param name="strRoleId"></param>
        //private void DataLoadRoleStorage(string strRoleId)
        //{
        //    try
        //    {
        //        string strroleStoragemodel = Newtonsoft.Json.JsonConvert.SerializeObject(new StorageInfoModel());
        //        string strListStorage = WebLockConfig.Instance.StorageInfo.GetStorageInfoDS(strroleStoragemodel, ref errText);
        //        roleStorage.ROLE_ID = strRoleId;
        //        string strroleStorage = Newtonsoft.Json.JsonConvert.SerializeObject(roleStorage);
        //        string strListRoleStorage = WebLockConfig.Instance.WebRoleStorage.execRoleStorageGetList(strroleStorage);
        //        if (errText.Trim().Length > 0)
        //        {
        //            SystemCommon.ShowErrorMessageBox(errText);
        //        }
        //        else
        //        {
        //            listStorage = Newtonsoft.Json.JsonConvert.DeserializeObject<List<StorageInfoModel>>(strListStorage);
        //            listRoleStorage = Newtonsoft.Json.JsonConvert.DeserializeObject<List<RoleStorageModel>>(strListRoleStorage);
        //            //bgsStorage.DataSource = listStorage;
        //        }
        //        List<StorageInfoModel> list = new List<StorageInfoModel>();
        //        listStorage.FindAll(delegate(StorageInfoModel target)
        //        {
        //            foreach (RoleStorageModel mod in listRoleStorage)
        //            {
        //                if (target.STORAGE_ID == mod.STORAGE_ID)
        //                {
        //                    list.Add(target);
        //                }
        //            }
        //            return true;
        //        });
        //        foreach (StorageInfoModel model in list)
        //        {
        //            model.IsCheckRec = true;
        //        }
        //        //GCStorage.DataSource = listStorage;
        //        //GVStorage.RefreshData();
        //        //GVStorage.ExpandGroupLevel(0, true);
        //    }
        //    catch
        //    {
        //        SystemCommon.ShowErrorMessageBox("加载失败,请重试!");
        //    }
        //}
        #endregion

        #region 角色点击行事件
        /// <summary>
        /// 角色点击行事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void GvRole_RowClick(object sender, DevExpress.XtraGrid.Views.Grid.RowClickEventArgs e)
        {
            if (flag == 0 || flag == 1 || flag == 2) { return; }

            int rowIndex = e.RowHandle;
            if (rowIndex < 0)
                return;
            roleModel = GvRole.GetRow(e.RowHandle) as RoleModel;


            if (frmButtonItem.ContainsKey("Edit")) { frmButtonItem["Edit"].Enabled = true; }
            if (frmButtonItem.ContainsKey("EditRole")) { frmButtonItem["EditRole"].Enabled = true; }
            if (frmButtonItem.ContainsKey("Del")) { frmButtonItem["Del"].Enabled = true; }


            bgsSelect.DataSource = roleModel;
            string strRoleId = roleModel.ROLE_ID;
            if (!string.IsNullOrEmpty(strRoleId))
            {
                LoadForm load = new LoadForm();
                DevExpress.XtraSplashScreen.SplashScreenManager.ShowForm(load, load.GetType(), false, true, false, 50);
                DevExpress.XtraSplashScreen.SplashScreenManager.Default.SetWaitFormCaption("");//设置标题
                DevExpress.XtraSplashScreen.SplashScreenManager.Default.SetWaitFormDescription("正在加载数据,请稍等....");
                switch (xtraTabControl1.SelectedTabPage.Name)
                {
                    case "PageMenu":
                        DataLoadRoleMenu(roleModel.ROLE_ID);
                        DataLoadRoleMenuFuc(roleModel.ROLE_ID);
                        GCFuc.DataSource = new List<MenuFuctionModel>();
                        GVFuc.RefreshData();
                        break;
                    case "PageGoods":
                        DataLoadRoleGoodsType(roleModel.ROLE_ID);
                        break;
                    case "PageProvider":
                        DataLoadRoleProvider(roleModel.ROLE_ID);
                        break;
                    //case "PageStorage":
                    //    DataLoadRoleStorage(roleModel.ROLE_ID);
                    //    break;
                    case "PageUser":
                        DataLoadRoleUser(roleModel.ROLE_ID);
                        break;
                    case "PageDepart":
                        DataLoadDepart(roleModel.ROLE_ID);
                        break;
                }
                DevExpress.XtraSplashScreen.SplashScreenManager.CloseForm();
            }
        }
        #endregion

        #region 节点处理
        string strIsCheck = string.Empty;
        TreeListNode node;
        /// <summary>
        /// 功能操作单元格值发生变化
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void CellValueChanging(object sender, DevExpress.XtraTreeList.CellValueChangedEventArgs e)
        {
            strIsCheck = e.Node.GetValue("IsCheckRec").ToString();
            node = e.Node;

            CheckState check;
            if (strIsCheck == "True")
            {
                check = CheckState.Unchecked;
            }
            else
            {
                check = CheckState.Checked;
            }
            SetCheckedChildNodes(node, check);//改变子节点的选中状态
            SetCheckedParentNodes(node, check);//改变父节点的选中状态

        }

        ///// <summary>
        ///// checkbox选中事件
        ///// </summary>
        ///// <param name="sender"></param>
        ///// <param name="e"></param>
        //private void ckMenuFun_CheckStateChanged(object sender, EventArgs e)
        //{
        //    CheckState check;
        //    if (((DevExpress.XtraEditors.CheckEdit)(sender)).EditValue.ToString() == "True")
        //    {
        //        check = CheckState.Checked;
        //    }
        //    else
        //    {
        //        check = CheckState.Unchecked;
        //    }
        //    SetCheckedChildNodes(node, check);
        //    SetCheckedParentNodes(node, check);
        //}

        /// <summary>
        /// 设置子节点的状态
        /// </summary>
        /// <param name="node"></param>
        /// <param name="Check"></param>
        private void SetCheckedChildNodes(TreeListNode node, CheckState check)
        {
            bool selected;
            if (check == CheckState.Checked)
                selected = true;
            else
                selected = false;

            node["IsCheckRec"] = selected;
            if (xtraTabControl1.SelectedTabPage.Text == "组织机构")
            {
                ChangeDepart(node);
            }
            if (xtraTabControl1.SelectedTabPage.Text == "功能操作")
            {
                ChangeMenu(node);
            }
            //if (xtraTabControl1.SelectedTabPage.Text == "商品分类")
            //{
            //    ChangeGoodsType(node);
            //}

            for (int i = 0; i < node.Nodes.Count; i++)
            {
                //node.Nodes[i]["IsCheckRec"] = selected;
                //ChangeDepart(node.Nodes[i]);

                SetCheckedChildNodes(node.Nodes[i], check);
            }
        }

        /// <summary>
        /// 设置父节点的状态
        /// </summary>
        /// <param name="node"></param>
        /// <param name="Check"></param>
        private void SetCheckedParentNodes(TreeListNode node, CheckState check)
        {
            if (node.ParentNode != null)
            {
                bool selected;
                if (check == CheckState.Checked)
                    selected = true;
                else
                    selected = false;

                bool b = false;
                CheckState state;
                for (int i = 0; i < node.ParentNode.Nodes.Count; i++)
                {
                    state = (CheckState)node.ParentNode.Nodes[i].CheckState;
                    if (!check.Equals(state))
                    {
                        b = !b;
                        break;
                    }
                }
                node.ParentNode.CheckState = b ? CheckState.Indeterminate : check;
                //node.ParentNode["IsCheckRec"] = selected;
                if (node.ParentNode.CheckState == CheckState.Indeterminate)
                {
                    node.ParentNode["IsCheckRec"] = selected;
                    //node.ParentNode.Checked = true;
                }
                else
                {
                    bool bflag = false;
                    for (int j = 0; j < node.ParentNode.Nodes.Count; j++)
                    {
                        if (node.ParentNode.Nodes[j]["IsCheckRec"].ToString() == "True")
                            bflag = true;
                    }
                    if (!bflag)
                    {
                        node.ParentNode["IsCheckRec"] = false;
                    }
                }
                if (xtraTabControl1.SelectedTabPage.Text == "组织机构")
                {
                    ChangeDepart(node);
                }
                if (xtraTabControl1.SelectedTabPage.Text == "功能操作")
                {
                    ChangeMenu(node);
                }
                //if (xtraTabControl1.SelectedTabPage.Text == "商品分类")
                //{
                //    ChangeGoodsType(node);
                //}
                SetCheckedParentNodes(node.ParentNode, check);
            }
        }
        #endregion

        #region 按钮事件

        // 新增按钮
        public override void Add()
        {
            //xtraTabControl1.Enabled = false;
            flag = 0;
            txtID.Focus();
            //this.splitContainerControl1.Panel2.Enabled = true;
            bgsSelect.DataSource = new RoleDictionaryModel();
            if (frmButtonItem.ContainsKey("Add")) { frmButtonItem["Add"].Enabled = false; }
            if (frmButtonItem.ContainsKey("Edit")) { frmButtonItem["Edit"].Enabled = false; }
            if (frmButtonItem.ContainsKey("EditRole")) { frmButtonItem["EditRole"].Enabled = false; }
            if (frmButtonItem.ContainsKey("Save")) { frmButtonItem["Save"].Enabled = true; }
            if (frmButtonItem.ContainsKey("Del")) { frmButtonItem["Del"].Enabled = false; }

            txtDIsc.Properties.ReadOnly = false;
            txtID.Properties.ReadOnly = false;
            txtName.Properties.ReadOnly = false;

            if (listMenu != null)
            {
                listMenu.Find(r => r.IsCheckRec = false);
            }
            GCMenu.RefreshDataSource();
        }


        // 删除按钮 
        public override void Del()
        {
            List<RoleDictionaryModel> dellist = new List<RoleDictionaryModel>();
            int[] selectRows = GvRole.GetSelectedRows();
            this.labelControl1.Focus();
            foreach (int j in selectRows)
            {
                RoleModel roleModel = new RoleModel();
                roleModel = this.GvRole.GetRow(j) as RoleModel;

                RoleDictionaryModel model = new RoleDictionaryModel();
                model.ROLE_DESC = roleModel.ROLE_DESC;
                model.ROLE_ID = roleModel.ROLE_ID;
                model.ROLE_NAME = roleModel.ROLE_NAME;
                dellist.Add(model);
            }
            if (dellist.Count == 0)
            {
                return;
            }
            if (DialogResult.OK == SystemCommon.ShowMessageBoxResult("确定删除"))
            {
                try
                {
                    // string strdel = Newtonsoft.Json.JsonConvert.SerializeObject(dellist);
                    string errText = IBussFactory<BussRoleDictionary>.Instance().DeleteRoleDictionaryList(dellist);
                    if (errText == "")
                    {
                        SystemCommon.ShowInfoMessageBox("删除成功！");
                    }
                    else
                    {
                        SystemCommon.ShowInfoMessageBox("删除失败！");
                    }
                }
                catch (Exception ex)
                {
                    SystemCommon.ShowErrorMessageBox("删除出错了：" + ex.Message);
                }
                this.splitContainerControl1.Panel2.Enabled = true;
                Refresh();
            }
        }

        /// <summary>
        /// 编辑权限
        /// </summary>
        public override void Edit()
        {
            if (!frmButtonItem.ContainsKey("Edit"))
            {
                return;
            }
            else if (frmButtonItem["Edit"].Enabled == false)
            {
                return;
            }

            //panelControl1.Enabled = false;

            //this.splitContainerControl1.Panel2.Enabled = true;

            if (frmButtonItem.ContainsKey("Edit")) { frmButtonItem["Edit"].Enabled = false; }
            if (frmButtonItem.ContainsKey("Del")) { frmButtonItem["Del"].Enabled = false; }
            if (frmButtonItem.ContainsKey("Add")) { frmButtonItem["Add"].Enabled = false; }
            if (frmButtonItem.ContainsKey("EditRole")) { frmButtonItem["EditRole"].Enabled = false; }
            if (frmButtonItem.ContainsKey("Save")) { frmButtonItem["Save"].Enabled = true; }
            //colISCHECK.OptionsColumn.AllowEdit = true;

            GvUser.OptionsBehavior.Editable = true;
            GVFuc.OptionsBehavior.Editable = true;
            GVProvider.OptionsBehavior.Editable = true;
            //GvRole.OptionsBehavior.Editable = true;
            //GVStorage.OptionsBehavior.Editable = true;
            GCMenu.OptionsBehavior.Editable = true;
            TreeDepart.OptionsBehavior.Editable = true;
            treeGoodsType.OptionsBehavior.Editable = true;
            GVMessage.OptionsBehavior.Editable = true;

            flag = 2;
        }

        /// <summary>
        /// 编辑角色
        /// </summary>
        public void EditRole()
        {
            //xtraTabControl1.Enabled = false;
            flag = 1;
            //this.splitContainerControl1.Panel2.Enabled = true;
            this.txtID.Enabled = false;
            if (frmButtonItem.ContainsKey("Edit")) { frmButtonItem["Edit"].Enabled = false; }
            if (frmButtonItem.ContainsKey("Del")) { frmButtonItem["Del"].Enabled = false; }
            if (frmButtonItem.ContainsKey("Add")) { frmButtonItem["Add"].Enabled = false; }
            if (frmButtonItem.ContainsKey("EditRole")) { frmButtonItem["EditRole"].Enabled = false; }
            if (frmButtonItem.ContainsKey("Save")) { frmButtonItem["Save"].Enabled = true; }
            //colISCHECK.OptionsColumn.AllowEdit = true;
            txtDIsc.Properties.ReadOnly = false;
            txtID.Properties.ReadOnly = false;
            txtName.Properties.ReadOnly = false;
        }

        private bool dataCheck()
        {
            if (string.IsNullOrEmpty(txtID.Text.Trim()))
            {
                SystemCommon.ShowInfoMessageBox("角色编号不能为空！");
                txtID.Focus();
                return false;
            }
            if (string.IsNullOrEmpty(txtName.Text.Trim()))
            {
                SystemCommon.ShowInfoMessageBox("角色名称不能为空！");
                txtName.Focus();
                return false;
            }
            if (txtDIsc.Text.Length > 300)
            {
                SystemCommon.ShowInfoMessageBox("角色描述信息过长,请重新输入");
                txtDIsc.Text = string.Empty;
                return false;
            }
            return true;
        }

        /// <summary>
        /// 保存
        /// </summary>
        public override void Save()
        {
            gridControlCustom1.Focus();

            errText = string.Empty;
            if (flag == 0 || flag == 1)
            {
                if (dataCheck())
                {
                    bgsSelect.EndEdit();
                    //string strRoleDictionary = Newtonsoft.Json.JsonConvert.SerializeObject(bgsSelect.DataSource);
                    //string strRoleMessage = Newtonsoft.Json.JsonConvert.SerializeObject(bgsMessage.DataSource);

                    try
                    {
                        //新增
                        if (flag == 0)
                        {
                            errText = IBussFactory<BussRoleDictionary>.Instance().AddRoleDictionary(bgsSelect.DataSource as RoleDictionaryModel);
                        }
                        //修改
                        else if (flag == 1)
                        {
                            RoleModel roleModel = bgsSelect.DataSource as RoleModel;
                            errText = IBussFactory<BussRoleDictionary>.Instance().UpdateRoleDictionary(new RoleDictionaryModel
                            {
                                ROLE_ID = roleModel.ROLE_ID,
                                ROLE_NAME = roleModel.ROLE_NAME,
                                ROLE_DESC = roleModel.ROLE_DESC
                            });
                        }
                    }
                    catch (Exception ex)
                    {
                        SystemCommon.ShowErrorMessageBox("保存出错了:" + ex.Message);
                        return;
                    }
                    if (string.IsNullOrEmpty(errText))
                    {
                        SystemCommon.ShowInfoMessageBox("保存成功！");

                        m_status = false;

                    }
                    else
                    {
                        SystemCommon.ShowInfoMessageBox("保存失败！");
                    }

                    if (frmButtonItem.ContainsKey("Edit")) { frmButtonItem["Edit"].Enabled = true; }
                    if (frmButtonItem.ContainsKey("Save")) { frmButtonItem["Save"].Enabled = false; }
                    if (frmButtonItem.ContainsKey("Add")) { frmButtonItem["Add"].Enabled = true; }
                    if (frmButtonItem.ContainsKey("Del")) { frmButtonItem["Del"].Enabled = true; }
                    this.txtID.Enabled = true;
                    //this.splitContainerControl1.Panel2.Enabled = false;
                    Refresh();
                }

                return;
            }

            errText = string.Empty;
            //GVStorage.CloseEditor();
            //GVStorage.UpdateCurrentRow();
            GVProvider.CloseEditor();
            GVProvider.UpdateCurrentRow();
            treeGoodsType.CloseEditor();
            treeGoodsType.Update();

            //  GVFuc.CloseEditor();
            GVFuc.UpdateCurrentRow();
            TreeDepart.CloseEditor();
            TreeDepart.Update();

            if (listMenuRoleAdd.Count > 0 || listMenuRoleDel.Count > 0)
            {
                errText += IBussFactory<BussMenuRole>.Instance().Save(listMenuRoleAdd, listMenuRoleDel);
            }

            if (listFuctionRoleAdd.Count > 0 || listFuctionRoleDel.Count > 0)
            {

                errText += IBussFactory<BussFunctionRole>.Instance().Save(listFuctionRoleAdd, listFuctionRoleDel);
            }

            bool departChanged = false;
            if (listDepartRoleAdd.Count > 0 || listDepartRoleDel.Count > 0)
            {
                departChanged = true;
                errText += IBussFactory<BussRoleDepart>.Instance().Save(listDepartRoleAdd, listDepartRoleDel);
            }

            //if (listGoodsTypeRoleAdd.Count > 0 || listGoodsTypeRoleDel.Count > 0)
            //{
            //    errText += IBussFactory<BussGoodsRole>.Instance().Save(listGoodsTypeRoleAdd, listGoodsTypeRoleDel);
            //}

            //if (listProviderRoleAdd.Count > 0 || listProviderRoleDel.Count > 0)
            //{
            //    errText += IBussFactory<BussProviderRole>.Instance().Save(listProviderRoleAdd, listProviderRoleDel);
            //}

            if (string.IsNullOrEmpty(errText))
            {
                SystemCommon.ShowInfoMessageBox("保存成功!");
                Init();
                DataLoadRole();

                DataLoadRoleUser(roleModel.ROLE_ID);

                if (departChanged)
                {
                    if (listUser.Count > 0)
                    {
                        if (DialogResult.OK == SystemCommon.ShowMessageBoxResult("您修改了当前角色的组织机构权限，该角色下存在用户，是否跳转到用户信息界面修改用户的组织机构权限"))
                        {
                            FormBase formBase = OpenFrmTable("WMS.FrmSystems", "FrmUser");//创建窗体
                            OpenTabAddFrm("0103", "WMS.FrmSystems", "用户信息");
                        }
                    }
                }
            }
            else
            {
                SystemCommon.ShowInfoMessageBox("保存失败" + errText);
            }
        }
        #endregion

        public override void Refresh()
        {

            if (frmButtonItem.ContainsKey("Save") && frmButtonItem["Save"].Enabled == true && flag != -1 && DialogResult.OK != SystemCommon.ShowMessageBoxResult("确定放弃正在编辑的数据？"))
            {
                return;
            }
            Init();

            DataLoadRole();

            DataLoadRoleUser(roleModel.ROLE_ID);


        }

        private void Init()
        {
            if (frmButtonItem.ContainsKey("Add"))
            {
                frmButtonItem["Add"].Enabled = true;
            }
            if (frmButtonItem.ContainsKey("Edit"))
            {
                frmButtonItem["Edit"].Enabled = true;
            }
            if (frmButtonItem.ContainsKey("Save"))
            {
                frmButtonItem["Save"].Enabled = false;
            }
            if (frmButtonItem.ContainsKey("Del"))
            {
                frmButtonItem["Del"].Enabled = true;
            }
            if (frmButtonItem.ContainsKey("EditRole"))
            {
                frmButtonItem["EditRole"].Enabled = true;
            }
            //listRoleStorageAdd.Clear();
            //listRoleStorageDel.Clear();
            listMenuRoleAdd.Clear();
            listMenuRoleDel.Clear();
            listProviderRoleAdd.Clear();
            listProviderRoleDel.Clear();
            listGoodsTypeRoleAdd.Clear();
            listGoodsTypeRoleDel.Clear();
            listFuctionRoleAdd.Clear();
            listFuctionRoleDel.Clear();

            //默认只读
            txtDIsc.Properties.ReadOnly = true;
            txtID.Properties.ReadOnly = true;
            txtName.Properties.ReadOnly = true;
            GvUser.OptionsBehavior.Editable = false;
            GVFuc.OptionsBehavior.Editable = false;
            GVProvider.OptionsBehavior.Editable = false;
            //GvRole.OptionsBehavior.Editable = false;
            //GVStorage.OptionsBehavior.Editable = false;
            GCMenu.OptionsBehavior.Editable = false;
            TreeDepart.OptionsBehavior.Editable = false;
            treeGoodsType.OptionsBehavior.Editable = false;
            GVMessage.OptionsBehavior.Editable = false;
            this.txtID.Enabled = true;
            flag = -1;
        }

        /// <summary>
        /// 菜单双击 编辑功能权限
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void GCMenu_DoubleClick(object sender, EventArgs e)
        {

            LoadForm load = new LoadForm();
            DevExpress.XtraSplashScreen.SplashScreenManager.ShowForm(load, load.GetType(), false, true, false, 50);
            DevExpress.XtraSplashScreen.SplashScreenManager.Default.SetWaitFormDescription("正在加载数据,请稍等....");
            if (GCMenu.FocusedNode.HasChildren)
            {
                GCFuc.DataSource = new List<MenuFuctionModel>();
            }
            else
            {
                string menu_Id = GCMenu.FocusedNode["MENU_ID"].ToString();
                DataLoadRoleMenuFuc(roleModel.ROLE_ID, menu_Id);
            }

            DevExpress.XtraSplashScreen.SplashScreenManager.CloseForm();
        }

        ///// <summary>
        ///// 仓库权限修改记录
        ///// </summary>
        ///// <param name="sender"></param>
        ///// <param name="e"></param>
        //private void GVStorage_CellValueChanged(object sender, DevExpress.XtraGrid.Views.Base.CellValueChangedEventArgs e)
        //{
        //    if (e.RowHandle < 0)
        //    {
        //        return;
        //    }
        //    StorageInfoModel model = GVStorage.GetRow(e.RowHandle) as StorageInfoModel;
        //    if (e.Column.FieldName == "IsCheckRec")
        //    {
        //        if (Convert.ToBoolean(e.Value))
        //        {
        //            if (listRoleStorageAdd.Find(r => r.STORAGE_ID == model.STORAGE_ID) == null && listRoleStorage.Find(r => r.STORAGE_ID == model.STORAGE_ID) == null)
        //            {
        //                listRoleStorageAdd.Add(new RoleStorageModel() { STORAGE_ID = model.STORAGE_ID, ROLE_ID = roleModel.ROLE_ID });
        //            }

        //            if (listRoleStorageDel.Find(r => r.STORAGE_ID == model.STORAGE_ID) != null)
        //            {
        //                listRoleStorageDel.Remove(listRoleStorageDel.Find(r => r.STORAGE_ID == model.STORAGE_ID));
        //            }
        //        }
        //        else
        //        {
        //            if (listRoleStorageDel.Find(r => r.STORAGE_ID == model.STORAGE_ID) == null && listRoleStorage.Find(r => r.STORAGE_ID == model.STORAGE_ID) != null)
        //            {
        //                listRoleStorageDel.Add(listRoleStorage.Find(r => r.STORAGE_ID == model.STORAGE_ID));
        //            }

        //            if (listRoleStorageAdd.Find(r => r.STORAGE_ID == model.STORAGE_ID) != null)
        //            {
        //                listRoleStorageAdd.Remove(listRoleStorageAdd.Find(r => r.STORAGE_ID == model.STORAGE_ID));
        //            }
        //        }
        //    }
        //}
        /// <summary>
        /// 供应商权限修改记录
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void GVProvider_CellValueChanged(object sender, DevExpress.XtraGrid.Views.Base.CellValueChangedEventArgs e)
        {
            if (e.RowHandle < 0)
            {
                return;
            }
            ProviderModel model = GVProvider.GetRow(e.RowHandle) as ProviderModel;
            if (e.Column.FieldName == "IsCheckRec")
            {
                if (Convert.ToBoolean(e.Value))
                {
                    if (listProviderRoleAdd.Find(r => r.PROVIDER_ID == model.PROVIDER_ID) == null && listProviderRole.Find(r => r.PROVIDER_ID == model.PROVIDER_ID) == null)
                    {
                        listProviderRoleAdd.Add(new ProviderRoleModel() { PROVIDER_ID = model.PROVIDER_ID, ROLE_ID = roleModel.ROLE_ID });
                    }

                    if (listProviderRoleDel.Find(r => r.PROVIDER_ID == model.PROVIDER_ID) != null)
                    {
                        listProviderRoleDel.Remove(listProviderRoleDel.Find(r => r.PROVIDER_ID == model.PROVIDER_ID));
                    }
                }
                else
                {
                    if (listProviderRoleDel.Find(r => r.PROVIDER_ID == model.PROVIDER_ID) == null && listProviderRole.Find(r => r.PROVIDER_ID == model.PROVIDER_ID) != null)
                    {
                        listProviderRoleDel.Add(listProviderRole.Find(r => r.PROVIDER_ID == model.PROVIDER_ID));
                    }

                    if (listProviderRoleAdd.Find(r => r.PROVIDER_ID == model.PROVIDER_ID) != null)
                    {
                        listProviderRoleAdd.Remove(listProviderRoleAdd.Find(r => r.PROVIDER_ID == model.PROVIDER_ID));
                    }
                }
            }
        }

        /// <summary>
        ///  菜单功能权限修改记录
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void GVFuc_CellValueChanged(object sender, DevExpress.XtraGrid.Views.Base.CellValueChangedEventArgs e)
        {
            if (e.RowHandle < 0)
            {
                return;
            }
            MenuFuctionModel model = GVFuc.GetRow(e.RowHandle) as MenuFuctionModel;
            if (e.Column.FieldName == "IsCheckRec")
            {
                if (Convert.ToBoolean(e.Value))
                {
                    if (listFuctionRoleAdd.Count(r => r.MENU_ID == model.MENU_ID && r.FUN_ID == model.FUN_ID) == 0 && listFuctionRole.Count(r => r.MENU_ID == model.MENU_ID && r.FUN_ID == model.FUN_ID) == 0)
                    {
                        listFuctionRoleAdd.Add(new FunctionRoleModel()
                        {
                            MENU_ID = model.MENU_ID,
                            FUN_ID = model.FUN_ID,
                            ROLE_ID = roleModel.ROLE_ID,
                            USER_ID = userData.USER_ID
                        });
                    }

                    if (listFuctionRoleDel.Count(r => r.MENU_ID == model.MENU_ID && r.FUN_ID == model.FUN_ID) > 0)
                    {
                        listFuctionRoleDel.Remove(listFuctionRoleDel.Find(r => r.MENU_ID == model.MENU_ID && r.FUN_ID == model.FUN_ID));
                    }
                }
                else
                {
                    if (listFuctionRoleDel.Count(r => r.MENU_ID == model.MENU_ID && r.FUN_ID == model.FUN_ID) == 0 && listFuctionRole.Count(r => r.MENU_ID == model.MENU_ID && r.FUN_ID == model.FUN_ID) > 0)
                    {
                        listFuctionRoleDel.Add(listFuctionRole.Find(r => r.MENU_ID == model.MENU_ID && r.FUN_ID == model.FUN_ID));
                    }

                    if (listFuctionRoleAdd.Count(r => r.MENU_ID == model.MENU_ID && r.FUN_ID == model.FUN_ID) > 0)
                    {
                        listFuctionRoleAdd.Remove(listFuctionRoleAdd.Find(r => r.MENU_ID == model.MENU_ID && r.FUN_ID == model.FUN_ID));
                    }
                }
            }
        }

        private void GVFuc_CustomDrawColumnHeader(object sender, DevExpress.XtraGrid.Views.Grid.ColumnHeaderCustomDrawEventArgs e)
        {
            if (e.Column != null && e.Column.FieldName == "IsCheckRec")
            {
                e.Info.InnerElements.Clear();
                e.Painter.DrawObject(e.Info);
                DevControlHelper.DrawCheckBox(e, m_status);
                e.Handled = true;
            }
        }

        private void GVFuc_Click(object sender, EventArgs e)
        {
            if (DevControlHelper.ClickGridCheckBox(this.GVFuc, "IsCheckRec", m_status))
            {
                m_status = !m_status;
            }
        }

        private void GVFuc_DataSourceChanged(object sender, EventArgs e)
        {
            GridColumn column = this.GVFuc.Columns.ColumnByFieldName("IsCheckRec");
            if (column != null)
            {
                column.Width = 20;
                if (column.OptionsColumn.ShowCaption != m_status)
                {
                    column.OptionsColumn.ShowCaption = m_status;
                }
                column.ColumnEdit = new RepositoryItemCheckEdit();
            }
        }

        private void xtraTabControl1_SelectedPageChanged(object sender, DevExpress.XtraTab.TabPageChangedEventArgs e)
        {
            if (string.IsNullOrEmpty(roleModel.ROLE_ID))
            {
                return;
            }

            LoadForm load = new LoadForm();
            DevExpress.XtraSplashScreen.SplashScreenManager.ShowForm(load, load.GetType(), false, true, false, 50);
            DevExpress.XtraSplashScreen.SplashScreenManager.Default.SetWaitFormDescription("正在加载数据,请稍等....");
            switch (e.Page.Name)
            {
                case "PageMenu":
                    DataLoadRoleMenu(roleModel.ROLE_ID);
                    DataLoadRoleMenuFuc(roleModel.ROLE_ID);
                    break;
                case "PageGoods":
                    DataLoadRoleGoodsType(roleModel.ROLE_ID);
                    break;
                case "PageProvider":
                    DataLoadRoleProvider(roleModel.ROLE_ID);
                    break;
                //case "PageStorage":
                //    DataLoadRoleStorage(roleModel.ROLE_ID);
                //    break;
                case "PageUser":
                    DataLoadRoleUser(roleModel.ROLE_ID);
                    break;
                case "PageDepart":
                    DataLoadDepart(roleModel.ROLE_ID);
                    break;
                case "PageMessage":
                    DataLoadMessageType(roleModel.ROLE_ID);
                    break;
            }
            DevExpress.XtraSplashScreen.SplashScreenManager.CloseForm();
        }

        private void ChangeChildNode(TreeListNode node)
        {
            if (node != null)
            {
                if (node.Nodes.Count > 0)
                {
                    foreach (TreeListNode n in node.Nodes)
                    {
                        n.Checked = node.Checked;
                        ChangeChildNode(n);
                    }
                }
            }
        }

        private void repositoryItemHyperLinkEdit1_Click(object sender, EventArgs e)
        {
            // FormBase formBase = OpenFrmTable();//创建窗体
            FormBase formBase = OpenFrmTable("WMS.FrmSystems", "FrmUser");//创建窗体
            OpenTabAddFrm("0103", "WMS.FrmSystems", "用户信息");

        }

        /// <summary>
        /// 商品分类权限修改记录
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void treeGoodsType_CellValueChanging(object sender, DevExpress.XtraTreeList.CellValueChangedEventArgs e)
        {
            if (e.Node == null)
            {
                return;
            }
            CellValueChanging(sender, e);
        }

        /// <summary>
        /// 商品分类权限修改记录
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ChangeGoodsType(TreeListNode node)
        {
            GoodsTypeModel model = new GoodsTypeModel() { GOODS_TYPE_ID = node["GOODS_TYPE_ID"].ToString() };
            //if (e.Column.FieldName == "IsCheckRec")
            //{
            if (node["IsCheckRec"].ToString() == "True")
            {
                if (listGoodsTypeRoleAdd.Find(r => r.GOODS_TYPE_ID == model.GOODS_TYPE_ID) == null && listGoodsTypeRole.Find(r => r.GOODS_TYPE_ID == model.GOODS_TYPE_ID) == null)
                {
                    listGoodsTypeRoleAdd.Add(new GoodsRoleModel() { GOODS_TYPE_ID = model.GOODS_TYPE_ID, ROLE_ID = roleModel.ROLE_ID });
                }

                if (listGoodsTypeRoleDel.Find(r => r.GOODS_TYPE_ID == model.GOODS_TYPE_ID) != null)
                {
                    listGoodsTypeRoleDel.Remove(listGoodsTypeRoleDel.Find(r => r.GOODS_TYPE_ID == model.GOODS_TYPE_ID));
                }
            }
            else
            {
                if (listGoodsTypeRoleDel.Find(r => r.GOODS_TYPE_ID == model.GOODS_TYPE_ID) == null && listGoodsTypeRole.Find(r => r.GOODS_TYPE_ID == model.GOODS_TYPE_ID) != null)
                {
                    listGoodsTypeRoleDel.Add(listGoodsTypeRole.Find(r => r.GOODS_TYPE_ID == model.GOODS_TYPE_ID));
                }

                if (listGoodsTypeRoleAdd.Find(r => r.GOODS_TYPE_ID == model.GOODS_TYPE_ID) != null)
                {
                    listGoodsTypeRoleAdd.Remove(listGoodsTypeRoleAdd.Find(r => r.GOODS_TYPE_ID == model.GOODS_TYPE_ID));
                }
            }
            //}
        }

        /// <summary>
        /// 菜单权限修改记录
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void GCMenu_CellValueChanging(object sender, DevExpress.XtraTreeList.CellValueChangedEventArgs e)
        {
            if (e.Node == null)
            {
                return;
            }
            CellValueChanging(sender, e);

        }

        private void ChangeMenu(TreeListNode node)
        {

            BaseMenuModel model = new BaseMenuModel() { MENU_ID = node["MENU_ID"].ToString() };


            if (node["IsCheckRec"].ToString() == "True")
            {
                //【新增添加菜单集合】 &&【已有菜单权限集合中没有】
                if (listMenuRoleAdd.Find(r => r.MENU_ID == model.MENU_ID) == null && listMenuRole.Find(r => r.MENU_ID == model.MENU_ID) == null)
                {
                    listMenuRoleAdd.Add(new MenuRoleModel() { MENU_ID = model.MENU_ID, ROLE_ID = roleModel.ROLE_ID });
                }
                //【从新增删除集合中去掉当前节点】
                if (listMenuRoleDel.Find(r => r.MENU_ID == model.MENU_ID) != null)
                {
                    listMenuRoleDel.Remove(listMenuRoleDel.Find(r => r.MENU_ID == model.MENU_ID));
                }
            }
            else
            {
                //【新增删除菜单集合】 &&【已有菜单权限集合中含有】
                if (listMenuRoleDel.Find(r => r.MENU_ID == model.MENU_ID) == null && listMenuRole.Find(r => r.MENU_ID == model.MENU_ID) != null)
                {
                    listMenuRoleDel.Add(listMenuRole.Find(r => r.MENU_ID == model.MENU_ID));
                }
                //【新增添加菜单集合 去掉被排除的】
                if (listMenuRoleAdd.Find(r => r.MENU_ID == model.MENU_ID) != null)
                {
                    listMenuRoleAdd.Remove(listMenuRoleAdd.Find(r => r.MENU_ID == model.MENU_ID));
                }
            }

        }

        /// <summary>
        /// 组织机构权限修改记录
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void TreeDepart_CellValueChanging(object sender, DevExpress.XtraTreeList.CellValueChangedEventArgs e)
        {
            if (e.Node == null)
            {
                return;
            }
            CellValueChanging(sender, e);

        }

        private void ChangeDepart(TreeListNode node)
        {
            CompanyModel model = new CompanyModel() { COM_ID = node["COM_ID"].ToString() };

            if (node["IsCheckRec"].ToString() == "True")
            {
                if (listDepartRoleAdd.Find(r => r.DEP_ID == model.COM_ID) == null && listDepartRole.Find(r => r.DEP_ID == model.COM_ID) == null)
                {
                    listDepartRoleAdd.Add(new RoleDepartModel() { DEP_ID = model.COM_ID, ROLE_ID = roleModel.ROLE_ID });
                }

                if (listDepartRoleDel.Find(r => r.DEP_ID == model.COM_ID) != null)
                {
                    listDepartRoleDel.Remove(listDepartRoleDel.Find(r => r.DEP_ID == model.COM_ID));
                }
            }
            else
            {
                if (listDepartRoleDel.Find(r => r.DEP_ID == model.COM_ID) == null && listDepartRole.Find(r => r.DEP_ID == model.COM_ID) != null)
                {
                    listDepartRoleDel.Add(listDepartRole.Find(r => r.DEP_ID == model.COM_ID));
                }

                if (listDepartRoleAdd.Find(r => r.DEP_ID == model.COM_ID) != null)
                {
                    listDepartRoleAdd.Remove(listDepartRoleAdd.Find(r => r.DEP_ID == model.COM_ID));
                }
            }

        }
    }
}