zoukankan      html  css  js  c++  java
  • BIM工程信息管理新系统- 系统管理模块

    系统管理模块

    1、实体类

      public partial class T_Role
        {
            public string RoleId { get; set; }
            public string RoleName { get; set; }
            public string CommentAry { get; set; }
            public string CodeNo { get; set; }
            public string CustomNo { get; set; }
            public string SpellNo { get; set; }
            public string StrokeNo { get; set; }
        }
    角色类
       public partial class T_Role_Privilege
        {
            public string RoleId { get; set; }
            public string Privid { get; set; }
            public string BarCaption { get; set; }
            public Nullable<int> BarOrder { get; set; }
            public string IsEndNode { get; set; }
            public Nullable<int> IsToolBar { get; set; }
            public string NodeID { get; set; }
            public string ParentNode { get; set; }
            public int Id { get; set; }
        }
    角色权限
      public partial class T_Operator
        {
            public string OperatorID { get; set; }
            public string DepID { get; set; }
            public string OperatorName { get; set; }
            public string Passwrod { get; set; }
            public string RoleID { get; set; }
            public string UserID { get; set; }
            public string CellPhone { get; set; }
            public string Emial { get; set; }
            public Nullable<int> LoginCount { get; set; }
            public string LastLoginTime { get; set; }
            public Nullable<int> State { get; set; }
            public string BuildMan { get; set; }
            public Nullable<System.DateTime> BuildDate { get; set; }
            public string EditMan { get; set; }
            public Nullable<System.DateTime> EditDate { get; set; }
        }
    操作用户
      public partial class T_Operator_Privilege
        {
            public string BarCaption { get; set; }
            public Nullable<int> BarOrder { get; set; }
            public string IsEndNode { get; set; }
            public Nullable<int> IsToolBar { get; set; }
            public string NodeId { get; set; }
            public string OperatorID { get; set; }
            public string ParentNode { get; set; }
            public string PrivId { get; set; }
            public int Id { get; set; }
        }
    用户权限
    public partial class T_Organization
        {
            public string F_OrgID { get; set; }
            public string F_OrgName { get; set; }
            public string F_OrgManager { get; set; }
            public Nullable<System.DateTime> F_BuildDate { get; set; }
            public string F_BuildMan { get; set; }
            public string F_TellPhoneNum { get; set; }
            public string F_Address { get; set; }
            public Nullable<bool> F_State { get; set; }
            public string F_ParentID { get; set; }
        }
    组织机构
      public partial class T_WholeMenu
        {
            public string NodeId { get; set; }
            public string NodeName { get; set; }
            public string ParentNode { get; set; }
            public string IsEndNode { get; set; }
            public string PluginId { get; set; }
            public string CommentAry { get; set; }
            public string Disporder { get; set; }
            public Nullable<int> Type { get; set; }
            public string GroupByName { get; set; }
            public string ImageIco { get; set; }
            public Nullable<int> TypeShow { get; set; }
            public Nullable<bool> IsStartUp { get; set; }
        }
    菜单管理
    public partial class Sys_Buttons
        {
            public int KeyId { get; set; }
            public string ButtonCaption { get; set; }
            public int Sortnum { get; set; }
            public string IconCls { get; set; }
            public string IconUrl { get; set; }
            public string ButtonTag { get; set; }
            public string Remark { get; set; }
            public string ButtonHtml { get; set; }
            public string BuggonGroup { get; set; }
            public int State { get; set; }
            public string ToolTip { get; set; }
        }
    按钮管理
     public partial class Sys_Button_Privilege
        {
            public int SysId { get; set; }
            public Nullable<int> ButtonId { get; set; }
            public string OperatorId { get; set; }
            public string RoleId { get; set; }
            public string NodeId { get; set; }
        }
    按钮权限管理
     public partial class Sys_WholeMenuButtons
        {
            public int KeyId { get; set; }
            public string MenuId { get; set; }
            public Nullable<int> ButtonId { get; set; }
            public Nullable<int> Sortnum { get; set; }
            public string ButtonName { get; set; }
        }
    菜单按钮

    2、服务器契约

    服务契约代码

    [ServiceContract(Namespace = "www.kubim.com/OperatorSerivce")]
    public interface IOperationpurviewService
    {
     #region 操作人员管理
    
            //添加人员
            [OperationContract(IsInitiating = true)]
            bool InsertOperatorInfo(T_Operator operatorEntity);
    
            ///<summary>
            ///修改操作T_Operator 
            /// </summary>
            [OperationContract(IsInitiating = true)]
            bool UpdateT_Operator(T_Operator model);
    
            ///<summary>
            ///修改操作T_Operator 
            /// </summary>
            [OperationContract(IsInitiating = true)]
            T_Operator T_OperatorById(string operatorid);
    
            ///<summary>
            ///删除操作T_Operator 
            ///  </summary>
            [OperationContract(IsInitiating = true)]
            bool DeleteT_Operator(String id);
    
            //获取最大人员编号
            [OperationContract(IsInitiating = true)]
            int GetMaxOperatorId();
    
            //获取所有人员
            [OperationContract(IsInitiating = true)]
            IQueryable<T_Operator> GetOperatorAllList();
    
            //根据用户登录的ID查询
            [OperationContract(IsInitiating = true)]
            List<FindMenuRigthByOperator> GetRightOperatorByOperatorId(string operatorid);
    
            //根据用户登录的ID查询
            [OperationContract(IsInitiating = true)]
            List<FindMenuRigthByOperator> GetRightOperatorByRoleId(string roleid);
    
            /// <summary>
            /// 用户登录
            /// </summary>
            /// <param name="loginUserName">登录名称</param>
            /// <param name="loginPassword">登录密码</param>
            /// <returns></returns>
            [OperationContract(IsInitiating = true)]
            bool LoginUser(string loginUserName, string loginPassword);
    
            /// <summary>
            /// 用户登录
            /// </summary>
            /// <param name="loginUserName">登录名称</param>
            /// <param name="loginPassword">登录密码</param>
            /// <param name="log">登录其它信息</param>
            /// <returns>返回字符串信息</returns>
            [OperationContract(IsInitiating = true)]
            string Login(string loginUserName, string loginPassword, params string[] log);
    
    
            /// <summary>
            /// 用户登陆
            /// </summary>
            /// <param name="loginUserName">Name of the login user.</param>
            /// <param name="loginPassword">The login password.</param>
            /// <param name="log">The log.</param>
            /// <returns>用户信息.</returns>
             [OperationContract(IsInitiating = true)]
            T_Operator LoginOperator(string loginUserName, string loginPassword, params string[] log);
    
            /// <summary>
            /// 用户登录次数添加
            /// </summary>
            /// <param name="operatorId">操作员ID</param>
            [OperationContract(IsInitiating = true)]
            bool OperatorAddLoginCount(T_Operator operatorId);
    
            /// <summary>
            /// 获取人员信息
            /// </summary>
            /// <param name="departId">以部门编号</param>
            [OperationContract(IsInitiating = true)]
            List<T_Operator> GetOperatorListByDepartId(string departId);
    
    
            /// <summary>
            /// 判斷用戶登陸名稱是否存在
            /// Determines whether [is existe login user name] [the specified login user name].
            /// </summary>
            /// <param name="loginUserName">Name of the login user.</param>
            /// <returns><c>true</c> if [is existe login user name] [the specified login user name]; otherwise, <c>false</c>.</returns>
             [OperationContract(IsInitiating = true)]
            bool IsExisteLoginUserName(string loginUserName);
    
            #endregion
    操作人员管理
            #region 用户角色管理
    
            //新增用户角色
            [OperationContract(IsInitiating = true)]
            bool InsertRoleInfo(T_Role roleEntity);
    
            /// <summary>
            /// 获取用户角色
            /// </summary>
            /// <param name="roleid">获取用户信息</param>
            /// <returns></returns>
            [OperationContract(IsInitiating = true)]
            T_Role T_RoleById(string roleid);
    
            ///<summary>
            ///修改操作T_Role 
            /// </summary>
            [OperationContract(IsInitiating = true)]
            bool UpdateT_Role(T_Role model);
    
            ///<summary>
            ///删除操作T_Role 
            /// </summary>
            [OperationContract(IsInitiating = true)]
            bool DeleteT_Role(String id);
    
            //获取用户角色人员信息
            [OperationContract(IsInitiating = true)]
            List<FindRoleRigthByRole> GetRoleRigthByRoleCode(string roleCode);
    
            //获取所有角色
            [OperationContract(IsInitiating = true)]
            List<T_Role> GetRoleAllList();
    
            //获取最大角色编号
            [OperationContract(IsInitiating = true)]
            int GetMaxRoleId();
    
            /// <summary>
            /// 修改用户密码
            /// </summary>
            /// <param name="oldPwd">旧的用户密码</param>
            /// <param name="newPwd">新的用户密码</param>
            /// <param name="userid">用户人员编号</param>
            /// <returns></returns>
            [OperationContract(IsInitiating = true)]
            string ChangeUserPwd(string oldPwd, string newPwd, string userid);
    
            #endregion
    用户角色管理
            #region 用户授权管理
    
            //新增用户权限信息
            [OperationContract(IsInitiating = true)]
            void InsertOperatorPrivilegeInfo(T_Operator_Privilege operatorEntity);
    
            //删除用户权限信息
            [OperationContract(IsInitiating = true)]
            void DeleteOperatorPrivilegeInfoByOperatorId(string operatorid);
    
            #endregion
    用户授权管理
           #region 角色授权管理
    
            //新增角色权限 
            [OperationContract(IsInitiating = true)]
            void InsertTRolePrivilege(T_Role_Privilege roleEntity);
    
            //删除角色权限
            [OperationContract(IsInitiating = true)]
            void DeleteRolePrivilegeByRoleId(string roleid);
    
            /// <summary>
            /// 添加项目权限
            /// </summary>
            /// <param name="projectLimitses">项目权限信息</param>
            /// <param name="typeinfo">操作员/角色 Operator/Role</param>
            /// <param name="typeid">角色编号/用户编号</param>
            /// <returns>bool</returns>
            [OperationContract(IsInitiating = true)]
            bool AddProjectLimits(List<T_ProjectLimits> projectLimitses, string typeinfo, string typeid);
            /// <summary>
            /// 添加机构数据权限
            /// </summary>
            /// <param name="organizationPrivileges">项目权限信息</param>
            /// <param name="typeinfo">操作员/角色 Operator/Role</param>
            /// <param name="typeid">角色编号/用户编号</param>
            /// <returns>bool</returns>
            [OperationContract(IsInitiating = true)]
            bool AddOrgizationLimits(List<T_Organization_Privilege> organizationPrivileges, string typeinfo, string typeid);
    
            /// <summary>
            /// 添加项目权限
            /// </summary>
            /// <param name="organizationPrivileges">项目权限信息</param>
            /// <param name="typeinfo">操作员/角色 Operator/Role</param>
            /// <param name="typeid">角色编号/用户编号</param>
            /// <returns>bool</returns>
            [OperationContract(IsInitiating = true)]
            bool AddLineMileageLimits(List<LineMileage_Privilege> organizationPrivileges, string typeinfo, string typeid);
            #endregion
    角色授权管理
            #region 菜单管理
    
            //添加菜单
            [OperationContract(IsInitiating = true)]
            void InsertTWholemenu(T_WholeMenu menuEntity);
            //修改菜单
            [OperationContract(IsInitiating = true)]
            bool UpdateTWholeMenu(T_WholeMenu menuEntity);
    
            //获取所有菜单
            [OperationContract(IsInitiating = true)]
            List<T_WholeMenu> GetAllWholeMenuList();
    
            //获取父菜单的ID
            [OperationContract(IsInitiating = true)]
            int GetTwholeMenuNodeId();
    
            //获取子菜单的ID
            [OperationContract(IsInitiating = true)]
            int GetTWholeMenuNodeChildrenId();
    
            //获取最大的菜单
            [OperationContract(IsInitiating = true)]
            int GetMaxWholeMenuId(string parentnode);
    
            //删除父节点下所有菜单
            [OperationContract(IsInitiating = true)]
            void DeleteWholeMenu(string parentid);
    
            //根据菜单编号删除下面所有信息
            [OperationContract(IsInitiating = true)]
            void DeleteWholeMenuNode(string nodeid);
    
            //保存用户权限
            [OperationContract(IsInitiating = true)]
            bool AddUserRight(DataTable dt, string type, string typeid);
    
            #endregion
    菜单管理
         #region 系统字典管理
    
            //添加字典信息
            [OperationContract(IsInitiating = true)]
            bool InsertDectionary(T_DictionaryInfo tInfo);
    
            //修改字典信息
            [OperationContract(IsInitiating = true)]
            bool UpdateDectionary(T_DictionaryInfo tInfo);
    
            //获取所有字典信息
            [OperationContract(IsInitiating = true)]
            List<T_DictionaryInfo> GetAllDictonaryList();
            //根据字典类型
            [OperationContract(IsInitiating = true)]
            List<T_DictionaryInfo> SearchDictionaryOfType(string fDictonaryType);
    
            //根据字典类型
            [OperationContract()]
            List<T_DictionaryInfo> SearchDictionaryOfTypeCode(string typeCode);
    
    
            //获取父菜单的编号
            [OperationContract(IsInitiating = true)]
            int GetMaxDictionaryParentCode();
    
            //获取子菜单的编号
            [OperationContract(IsInitiating = true)]
            int GetDictionaryNodeChildrenCode();
    
            //获取最大的菜单
            [OperationContract(IsInitiating = true)]
            int GetMaxDictionaryCode(string parentCode);
    
            //删除子菜单
            [OperationContract(IsInitiating = true)]
            bool DeleteDictionaryChildrenCode(string dictonaryCode);
            //删除父菜和下面的所有的子菜单
            bool DeleteDictonaryCode(string parnentdictonaryCode);
    
            //数据库名称
            [OperationContract(IsInitiating = true)]
            DataTable GetAllTableNameByDb(string dataBaseName);
    
            //获取父节点下的子节点的Count
            [OperationContract(IsInitiating = true)]
            int GetDictionaryCountByParentCode(string parentCode);
    
            //根据字典编号获取明细信息
            [OperationContract(IsInitiating = true)]
            T_DictionaryInfo GetTDictonaryInfo(string dictonaryCode);
    
    
    
    
            #endregion
    系统字典管理
       #region 组织机构
    
            /// <summary>
            /// 新增操作T_Organization
            /// </summary>
            /// <param name="model">The model.</param>
            /// <param name="operatorid">The operatorid.</param>
            /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
            [OperationContract(IsInitiating = true)]
            bool InsertT_Organization(T_Organization model,string operatorid);
    
            ///<summary>
            ///修改操作T_Organization 
            /// </summary>
            [OperationContract(IsInitiating = true)]
            bool UpdateT_Organization(T_Organization model);
    
            ///<summary>
            ///删除操作T_Organization 
            /// </summary>
            [OperationContract(IsInitiating = true)]
            bool DeleteT_Organization(String id);
    
            ///<summary>
            ///获取所有数据T_Organization 
            /// </summary>
            [OperationContract(IsInitiating = true)]
            List<T_Organization> GetT_OrganizationListData();
    
            /// <summary>
            /// 根据用户判断当前组织机构信息 </summary>
            /// <param name="operatorId"></param>
            /// <returns></returns>
            [OperationContract(IsInitiating = true)]
            IQueryable<T_Organization> GetT_OrganizationBy(string operatorId);
    
    
            #endregion
    组织机构
          #region 机构权限
            /// <summary>
            ///根据SQL语句查询返回IQueryableT_Organization_Privilege
            /// <param name="sql">T_Organization_PrivilegeSQL语句</param>
            /// </summary>
            [OperationContract]
            IQueryable<T_Organization_Privilege> GetT_Organization_PrivilegeBySql(string sql, params object[] obj);
    
            /// <summary>
            ///获取实体T_Organization_Privilege
            /// <param name="id">主键编号</param>
            /// </summary>
            [OperationContract]
            List<T_Organization_Privilege> GetT_Organization_PrivilegeById(string id);
    
            /// <summary>
            ///修改实体T_Organization_Privilege
            /// <param name="entity">T_Organization_Privilege实体</param>
            /// </summary>
            [OperationContract]
            bool UpdateT_Organization_Privilege(List<T_Organization_Privilege> entity);
    
            /// <summary>
            ///新增实体T_Organization_Privilege
            /// <param name="entity">T_Organization_Privilege实体</param>
            /// </summary>
            [OperationContract]
            bool CreateT_Organization_Privilege(List<T_Organization_Privilege> entity, string operatorId);
    
    
            /// <summary>
            ///新增实体T_Organization_Privilege
            /// <param name="entity">T_Organization_Privilege实体</param>
            /// </summary>
            [OperationContract]
            bool CreateT_Organization_PrivilegeEntity(T_Organization_Privilege entity);
    
            /// <summary>
            ///删除T_Organization_Privilege
            /// <param name="id">主键编号</param>
            /// </summary>
            [OperationContract]
            bool DeleteT_Organization_Privilege(List<int> id);
    
    
    
            /// <summary>
            ///获取实体LineMileage_Privilege
            /// <param name="id">主键编号</param>
            /// </summary>
            [OperationContract]
            LineMileage_Privilege GetLineMileage_PrivilegeById(string id);
    
            /// <summary>
            ///修改实体LineMileage_Privilege
            /// <param name="entity">LineMileage_Privilege实体</param>
            /// </summary>
            [OperationContract]
            bool UpdateLineMileage_Privilege(LineMileage_Privilege entity);
    
            /// <summary>
            ///新增实体LineMileage_Privilege
            /// <param name="entity">LineMileage_Privilege实体</param>
            /// </summary>
            [OperationContract]
            bool CreateLineMileage_Privilege(List<LineMileage_Privilege> entity, string operatorId);
    
            /// <summary>
            ///删除LineMileage_Privilege
            /// <param name="id">主键编号</param>
            /// </summary>
            [OperationContract]
            bool DeleteLineMileage_Privilege(string id);
    
            /// <summary>
            /// 获取线路里程权限信息
            /// </summary>
            /// <param name="strsql">sql</param>
            /// <param name="obj">参数</param>
            /// <returns>IQueryable</returns>
            [OperationContract]
            IQueryable<T_ProjectLimits> GetT_ProjectLimitsBySql(string strsql, params object[] obj);
    
            /// <summary>
            ///根据SQL语句查询返回IQueryableLineMileage_Privilege
            /// <param name="sql">LineMileage_PrivilegeSQL语句</param>
            /// </summary>
            [OperationContract]
            IQueryable<LineMileage_Privilege> GetLineMileage_PrivilegeBySql(string sql, params CmdParameter[] obj);
    
            /// <summary>
            ///新增实体T_ProjectLimits
            /// <param name="entity">T_ProjectLimits实体</param>
            /// </summary>
            [OperationContract]
            bool CreateT_ProjectLimits_Privilege(List<T_ProjectLimits> entity, string operatorId);
    
            /// <summary>
            /// 获取当前用户的信息
            /// </summary>
            /// <param name="operatorid"></param>
            /// <returns></returns>
            [OperationContract]
            IQueryable<T_ProjectLimits> GetT_ProjectLimitsByOperator(string operatorid);
    
            #endregion
    机构权限
            #region 系统菜单按钮
    
    
            /// <summary>
            ///获取实体Sys_Buttons
            /// <param name="id">主键编号</param>
            /// </summary>
            [OperationContract]
            Sys_Buttons GetSys_ButtonsById(int id);
    
            /// <summary>
            ///修改实体Sys_Buttons
            /// <param name="entity">Sys_Buttons实体</param>
            /// </summary>
            [OperationContract]
            bool UpdateSys_Buttons(Sys_Buttons entity);
    
            /// <summary>
            ///新增实体Sys_Buttons
            /// <param name="entity">Sys_Buttons实体</param>
            /// </summary>
            [OperationContract]
            bool CreateSys_Buttons(Sys_Buttons entity);
    
            /// <summary>
            ///删除Sys_Buttons
            /// <param name="id">主键编号</param>
            /// </summary>
            [OperationContract]
            bool DeleteSys_Buttons(int id);
    
            [OperationContract]
            IQueryable<Sys_WholeMenuButtons> GetSys_WholeMenuButtonsBySql(string sql, params CmdParameter[] obj);
            /// <summary>
            ///根据SQL语句查询返回IQueryableSys_Buttons
            /// <param name="sql">Sys_ButtonsSQL语句</param>
            /// </summary>
            [OperationContract]
            IQueryable<Sys_Buttons> GetSys_ButtonsBySql(string sql, params CmdParameter[] obj);
    
            /// <summary>
            /// 返回菜单的按钮
            /// </summary>
            /// <param name="menuId">菜单编号</param>
            /// <returns></returns>
            [OperationContract]
            List<TWholeMenuButton> GetTWholeMenuButtons(string menuId);
    
            /// <summary>
            /// 返回所有的菜单信息
            /// </summary>
            /// <returns></returns>
            [OperationContract]
            List<TWholeMenuButton> GetTWholeMenuButtonsAllList();
            /// <summary>
            /// 获取对应的权限
            /// </summary>
            /// <param name="operatorId">操作员ID</param>
            /// <returns></returns>
            [OperationContract]
            List<TWholeMenuButton> GetButtonLimitsAlList(string operatorId);
    
            /// <summary>
            /// 获取对应的权限
            /// </summary>
            /// <param name="roleId">角色ID</param>
            /// <returns></returns>
            [OperationContract]
            List<TWholeMenuButton> GetButtonLimitstRoleAllList(string roleId);
            /// <summary>
            ///新增实体Sys_WholeMenuButtons
            /// <param name="entity">Sys_WholeMenuButtons实体</param>
            /// </summary>
            [OperationContract]
            bool CreateSys_WholeMenuButtons(List<Sys_WholeMenuButtons> entity);
    
            /// <summary>
            ///删除Sys_WholeMenuButtons
            /// <param name="nodeid">主键编号</param>
            /// </summary>
            [OperationContract]
            bool DeleteSys_WholeMenuButtons(string nodeid);
    
            /// <summary>
            /// 根据用户获取项目权限
            /// </summary>
            /// <param name="operatorId">操作员编号</param>
            /// <returns></returns>
            [OperationContract]
            IQueryable<ProjectsLimits> GetProjectsLimitsesByOperator(string operatorId);
    
            /// <summary>
            /// 根据用户编号获取对应的线程里程信息
            /// </summary>
            /// <param name="operatorId">操作员编号</param>
            /// <param name="projectKey">项目编号</param>
            /// <returns></returns>
            [OperationContract]
            IEnumerable<LineMileageLimits> GetLineMileageLimitsesByOperator(string operatorId, string projectKey);
    
            #endregion
    系统菜单按钮
    }

    3、服务契约实现

    服务类代码

        //服务
        /// <summary>
        /// Class OperationService.
        /// </summary>
        [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
        public class OperationService : IOperationpurviewService, IDisposable
        {
            private readonly RBIM5D_PROJECTContext _dbContext;
            public OperationService()
            {
                _dbContext = new RBIM5D_PROJECTEntities();
            }
     #region 操作人员管理
            public bool InsertOperatorInfo(T_Operator operatorEntity)
            {
                try
                {
    
                    _dbContext.Set<T_Operator>().Attach(operatorEntity);
                    _dbContext.Set<T_Operator>().Add(operatorEntity);
                    _dbContext.SaveChanges();
                }
                catch (DbEntityValidationException ex)
                {
                    throw ex.InnerException;  
                }
                catch (DbException ee)
                {
                    throw ee.InnerException;
                }
                return true;
            }
    
            /// <summary>
            /// 修改操作T_Operator
            /// </summary>
            /// <param name="model">The model.</param>
            /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
            public bool UpdateT_Operator(T_Operator model)
            {
                try
                {
                    var category = _dbContext.T_Operator.FirstOrDefault(o => o.OperatorID == model.OperatorID);
                    if (category != null)
                    {
                        category.OperatorID = model.OperatorID;
                        category.DepID = model.DepID;
                        category.OperatorName = model.OperatorName;
                        category.Passwrod = model.Passwrod;
                        category.RoleID = model.RoleID;
                        category.UserID = model.UserID;
                        category.CellPhone = model.CellPhone;
                        category.Emial = model.Emial;
                        category.State = model.State;
                        category.EditMan = model.EditMan;
                        category.EditDate = model.EditDate;
                    }
                    _dbContext.SaveChanges();
                }
                catch (EntityException)
                {
                    return false;
                }
                catch (Exception)
                {
                    return false;
                }
                return true;
            }
    
            /// <summary>
            /// 修改操作T_Operator
            /// </summary>
            /// <param name="operatorid">The operatorid.</param>
            /// <returns>T_Operator.</returns>
            public T_Operator T_OperatorById(string operatorid)
            {
                try
                {
                    return _dbContext.Set<T_Operator>().FirstOrDefault(o => o.OperatorID == operatorid && o.State == 0);
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            /// <summary>
            /// 删除操作T_Operator
            /// </summary>
            /// <param name="id">The identifier.</param>
            /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
            public bool DeleteT_Operator(string id)
            {
                try
                {
    
                    T_Operator category = _dbContext.T_Operator.First(o => o.OperatorID == id);
                    return LU.DAL.BaseDAL<T_Operator>.ManagerContent(_dbContext).Del(category);
    
                }
                catch (EntityException)
                {
                    return false;
                }
                catch (Exception)
                {
                    return false;
                }
            }
    
            /// <summary>
            /// Gets the maximum operator identifier.
            /// </summary>
            /// <returns>System.Int32.</returns>
            public int GetMaxOperatorId()
            {
    
    
                try
                {
                    const string strsql = "select max(Convert(int,OperatorID)) from T_Operator";
                    return _dbContext.Database.SqlQuery<int>(strsql).First();
    
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
    
            }
    
            public IQueryable<T_Operator> GetOperatorAllList()
            {
                try
                {
                    return _dbContext.T_Operator.Where(o => o.State == 0);
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            /// <summary>
            /// Gets the right operator by operator identifier.
            /// </summary>
            /// <param name="operatorid">The operatorid.</param>
            /// <returns>List&lt;FindMenuRigthByOperator&gt;.</returns>
            public List<FindMenuRigthByOperator> GetRightOperatorByOperatorId(string operatorid)
            {
                try
                {
                    var list = new List<FindMenuRigthByOperator>();
    
                    {
                        var query = from a in _dbContext.T_Operator_Privilege
                                    join b in _dbContext.T_WholeMenu on a.NodeId equals b.NodeId
                                    where a.OperatorID == operatorid
                                    select new
                                        {
                                            a.OperatorID,
                                            ParentNode1 = a.ParentNode,
                                            a.NodeId,
                                            a.IsEndNode,
                                            a.PrivId,
                                            a.IsToolBar,
                                            a.BarOrder,
                                            a.BarCaption,
                                            b.NodeName,
                                            b.ParentNode,
                                            b.PluginId,
                                            b.CommentAry,
                                            b.Disporder,
                                            b.Type,
                                            b.GroupByName,
                                            b.ImageIco,
                                            b.TypeShow,
                                            b.IsStartUp
                                        };
                        if (query.Any())
                        {
                            list.AddRange(query.ToList().Select(item => new FindMenuRigthByOperator
                                {
                                    BarCaption = item.BarCaption,
                                    BarOrder = item.BarOrder,
                                    CommentAry = item.CommentAry,
                                    IsEndNode = item.IsEndNode,
                                    IsToolBar = item.IsToolBar,
                                    NodeId = item.NodeId,
                                    NodeName = item.NodeName,
                                    ParentNode1 = item.ParentNode1,
                                    ParentNode = item.ParentNode,
                                    PluginId = item.PluginId,
                                    PrivId = item.PrivId,
                                    GroupByName = item.GroupByName,
                                    ImageIco = item.ImageIco,
                                    TypeShow = item.TypeShow,
                                    IsStartUp = item.IsStartUp,
    
                                }));
    
                        }
    
                    } return list;
                }
                catch (EntityException e)
                {
                    throw e.InnerException;
                }
    
            }
    
            /// <summary>
            /// Gets the right operator by role identifier.
            /// </summary>
            /// <param name="roleid">The roleid.</param>
            /// <returns>List&lt;FindMenuRigthByOperator&gt;.</returns>
            public List<FindMenuRigthByOperator> GetRightOperatorByRoleId(string roleid)
            {
                try
                {
                    var list = new List<FindMenuRigthByOperator>();
    
                    {
                        var query = from a in _dbContext.T_Role_Privilege
                                    join b in _dbContext.T_WholeMenu on a.NodeID equals b.NodeId
                                    where a.RoleId == roleid
                                    select new
                                    {
                                        a.RoleId,
                                        ParentNode1 = a.ParentNode,
                                        a.NodeID,
                                        a.IsEndNode,
                                        a.Privid,
                                        a.IsToolBar,
                                        a.BarOrder,
                                        a.BarCaption,
                                        b.NodeName,
                                        b.ParentNode,
                                        b.PluginId,
                                        b.CommentAry,
                                        b.Disporder,
                                        b.Type,
                                        b.GroupByName,
                                        b.ImageIco,
                                        b.TypeShow,
                                        b.IsStartUp
                                    };
                        if (query.Any())
                        {
                            list.AddRange(query.ToList().Select(item => new FindMenuRigthByOperator
                            {
                                BarCaption = item.BarCaption,
                                BarOrder = item.BarOrder,
                                CommentAry = item.CommentAry,
                                IsEndNode = item.IsEndNode,
                                IsToolBar = item.IsToolBar,
                                NodeId = item.NodeID,
                                NodeName = item.NodeName,
                                ParentNode1 = item.ParentNode1,
                                ParentNode = item.ParentNode,
                                PluginId = item.PluginId,
                                PrivId = item.Privid,
                                GroupByName = item.GroupByName,
                                ImageIco = item.ImageIco,
                                TypeShow = item.TypeShow,
                                IsStartUp = item.IsStartUp
                            }));
    
                        }
    
                    } return list;
                }
                catch (EntityException e)
                {
                    throw e.InnerException;
                }
            }
    
            /// <summary>
            /// 用户登录
            /// </summary>
            /// <param name="loginUserName">登录名称</param>
            /// <param name="loginPassword">登录密码</param>
            /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
            public bool LoginUser(string loginUserName, string loginPassword)
            {
                if (string.IsNullOrEmpty(loginUserName) || string.IsNullOrEmpty(loginPassword))
                    return false;
                try
                {
    
                    // ReSharper disable ImplicitlyCapturedClosure
                    var queryExits = _dbContext.T_Operator.Where(o => o.OperatorID == loginUserName);
                    // ReSharper restore ImplicitlyCapturedClosure
                    if (queryExits.Any())
                    {
                        string password = EncodeHelper.DesEncrypt(loginPassword);
                        var queryLogin = _dbContext.T_Operator.Where(o => o.OperatorID == loginUserName && o.Passwrod == password);
                        if (queryLogin.Any())
                        {
                            var firstOrDefault = queryLogin.FirstOrDefault();
                            if (firstOrDefault != null)
                                OperatorAddLoginCount(firstOrDefault);
                            return true;
                        }
                        return false;
                    }
    
    
                }
                catch (EntityException)
                {
                    return false;
                }
                return false;
            }
    
            /// <summary>
            /// 用户登录
            /// </summary>
            /// <param name="loginUserName">登录名称</param>
            /// <param name="loginPassword">登录密码</param>
            /// <param name="log">登录其它信息</param>
            /// <returns>返回字符串信息</returns>
            public string Login(string loginUserName, string loginPassword, params string[] log)
            {
                if (string.IsNullOrEmpty(loginUserName) || string.IsNullOrEmpty(loginPassword))
                    return "用户或密码不能为空!谢谢";
                try
                {
                    T_Operator queryExits = _dbContext.T_Operator.FirstOrDefault(o => o.OperatorID == loginUserName);
                    if (queryExits != null)
                    {
                        if (queryExits.State == 0)
                        {
                            string password = EncodeHelper.DesEncrypt(loginPassword);
                            var queryLogin = _dbContext.T_Operator.FirstOrDefault(o => o.OperatorID == loginUserName && o.Passwrod == password);
                            if (queryLogin != null)
                            {
                                OperatorAddLoginCount(queryLogin);
    
                                return "success";
                            }
                            return "密码与当前用户不匹配!请从新尝试!";
                        }
                        return "尊敬的用户您好!您的账户已经锁定或无效!请联系系统管理员!谢谢";
                    }
                    return "系统中没有查找到该用户!请查看用户名称是否正确!谢谢";
                }
                catch (EntityException ex)
                {
                    LogHelper.Info("用户登录", ex);
                    return "服务端数据库打开无法连接!请联系系统管理!谢谢";
                }
                catch (Exception ex)
                {
                    LogHelper.Info("用户登录", ex);
                    return "登录失败!";
                }
            }
    
            /// <summary>
            /// 用户登陆
            /// </summary>
            /// <param name="loginUserName">Name of the login user.</param>
            /// <param name="loginPassword">The login password.</param>
            /// <param name="log">The log.</param>
            /// <returns>用户信息.</returns>
            public T_Operator LoginOperator(string loginUserName, string loginPassword, params string[] log)
            {
                if (string.IsNullOrEmpty(loginUserName) || string.IsNullOrEmpty(loginPassword))
                    return null;
                try
                {
                    string loginUser = loginUserName.ToLower();
                    T_Operator queryExits = _dbContext.T_Operator.FirstOrDefault(o => o.OperatorID.ToLower() == loginUser || o.UserID.ToLower() == loginUser);
                    if (queryExits != null)
                    {
                        if (queryExits.State == 0)
                        {
                            string password = EncodeHelper.DesEncrypt(loginPassword);
                            if (queryExits.Passwrod == password)
                            {
                                OperatorAddLoginCount(queryExits);
    
                                return queryExits;
                            }
                        }
                    
                    }
                    return null;
                }
                catch (EntityException ex)
                {
                    LogHelper.Info("用户登录", ex);
                    throw ex;
                }
                catch (Exception ex)
                {
                    LogHelper.Info("用户登录", ex);
                    throw ex;
                }
            }
    
            /// <summary>
            /// 用户登录次数添加
            /// </summary>
            /// <param name="operatorId">操作员ID</param>
            /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
            public bool OperatorAddLoginCount(T_Operator operatorId)
            {
                if (operatorId != null)
                {
                    _dbContext.Sys_logs.Add(new Sys_logs
                    {
                        BusinessName = "用户登录",
                        OperationIp = operatorId.OperatorID,
                        OperationTime = DateTime.Now
                    });
                    operatorId.LoginCount = operatorId.LoginCount == null ? 0 : operatorId.LoginCount + 1;
                    operatorId.LastLoginTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                }
                _dbContext.SaveChanges();
    
                return false;
            }
    
            /// <summary>
            /// 获取人员信息
            /// </summary>
            /// <param name="departId">以部门编号</param>
            /// <returns>List&lt;T_Operator&gt;.</returns>
            public List<T_Operator> GetOperatorListByDepartId(string departId)
            {
                try
                {
                    return _dbContext.Set<T_Operator>().Where(@operator => @operator.DepID == departId).ToList();
    
                }
                catch (EntityException e)
                {
    
                    throw e.InnerException;
                }
            }
    
            /// <summary>
            /// 判斷用戶登陸名稱是否存在
            /// Determines whether [is existe login user name] [the specified login user name].
            /// </summary>
            /// <param name="loginUserName">Name of the login user.</param>
            /// <returns><c>true</c> if [is existe login user name] [the specified login user name]; otherwise, <c>false</c>.</returns>
            public bool IsExisteLoginUserName(string loginUserName)
            {
                T_Operator tOperator = _dbContext.T_Operator.FirstOrDefault(o => o.UserID == loginUserName);
                if (tOperator != null)
                    return true;
                return false;
            }
    
            /// <summary>
            /// Gets the toperators by role identifier.
            /// </summary>
            /// <param name="roleid">The roleid.</param>
            /// <returns>List&lt;T_Operator&gt;.</returns>
            List<T_Operator> GetToperatorsByRoleId(string roleid)
            {
                try
                {
                    return _dbContext.Set<T_Operator>().Where(o => o.RoleID == roleid).ToList();
                }
                catch (SqlException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            /// <summary>
            /// 修改用户密码
            /// </summary>
            /// <param name="oldPwd">旧的用户密码</param>
            /// <param name="newPwd">新的用户密码</param>
            /// <param name="userid">用户人员编号</param>
            /// <returns>System.String.</returns>
            public string ChangeUserPwd(string oldPwd, string newPwd, string userid)
            {
    
                string password = EncodeHelper.DesEncrypt(oldPwd);
                var istrue = _dbContext.T_Operator.FirstOrDefault(o => o.OperatorID == userid && o.Passwrod == password);
                if (istrue != null)
                {
                    istrue.Passwrod = EncodeHelper.DesEncrypt(newPwd);
                    _dbContext.SaveChanges();
                }
                else
                {
                    return "当前的用户密码不正确!";
                }
    
                return "成功";
            }
    
            #endregion
    操作人员管理
       #region 用户权限管理
    
            public void InsertOperatorPrivilegeInfo(T_Operator_Privilege operatorEntity)
            {
    
                try
                {
                    //  _enity.Attach(operatorEntity);
                    _dbContext.Set<T_Operator_Privilege>().Add(operatorEntity);
                    //  _enity.ObjectStateManager.ChangeObjectState(operatorEntity, EntityState.Added);
                    _dbContext.SaveChanges();
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
            }
    
            public void DeleteOperatorPrivilegeInfoByOperatorId(string operatorid)
            {
    
                try
                {
                    //  _enity.ExecuteStoreCommand("delete from  T_Operator_Privilege where Operatorid=@operatorids", new SqlParameter("@operatorids", operatorid));
                    var rsult = from fx in _dbContext.T_Operator_Privilege where fx.OperatorID == operatorid select fx;
                    if (rsult.Any())
                    {
                        foreach (var privilege in rsult)
                        {
                            _dbContext.T_Operator_Privilege.Remove(privilege);
                        }
                        _dbContext.SaveChanges();
                    }
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
    
    
    
    
            }
    
            #endregion
    用户权限管理
    #region 用户角色
    
            //新增角色
            public bool InsertRoleInfo(T_Role roleEntity)
            {
                try
                {
                    _dbContext.T_Role.Add(roleEntity);
                    _dbContext.SaveChanges();
                    return true;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
    
    
            }
    
            public T_Role T_RoleById(string roleid)
            {
                try
                {
                    return _dbContext.Set<T_Role>().FirstOrDefault(o => o.RoleId == roleid && o.CodeNo == "有效");
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            ///<summary>
            ///修改操作T_Role 
            /// </summary>
            public bool UpdateT_Role(T_Role model)
            {
                try
                {
    
                    var category = _dbContext.T_Role.FirstOrDefault(o => o.RoleId == model.RoleId);
                    if (category != null)
                    {
                        category.RoleId = model.RoleId;
                        category.RoleName = model.RoleName;
                        category.CommentAry = model.CommentAry;
                        category.CodeNo = model.CodeNo;
                        category.CustomNo = model.CustomNo;
                        category.SpellNo = model.SpellNo;
                        category.StrokeNo = model.StrokeNo;
                    }
                    _dbContext.SaveChanges();
    
                }
                catch (EntityException)
                {
                    return false;
                }
                catch (Exception)
                {
                    return false;
                }
                return true;
            }
            ///<summary>
            ///删除操作T_Role 
            /// </summary>
            public bool DeleteT_Role(string model)
            {
                try
                {
    
                    var category = _dbContext.T_Role.Where(o => o.RoleId == model);
                    if (category.Any())
                    {
                        foreach (var item in category)
                        {
                            _dbContext.Set<T_Role>().Attach(item);
                            _dbContext.Set<T_Role>().Remove(item);
                        }
                        _dbContext.SaveChanges();
                    }
    
                }
                catch (EntityException)
                {
                    return false;
                }
                catch (Exception)
                {
                    return false;
                }
                return true;
            }
    
            //返回角色权限信息
            public List<FindRoleRigthByRole> GetRoleRigthByRoleCode(string roleCode)
            {
                var list = new List<FindRoleRigthByRole>();
    
                var query = from a in _dbContext.T_Role_Privilege
                            join b in _dbContext.T_WholeMenu on a.NodeID equals b.NodeId
                            where
                                a.RoleId == roleCode
                            select new
                                {
                                    a.RoleId,
                                    ParentNode1 = a.ParentNode,
                                    a.NodeID,
                                    a.IsEndNode,
                                    a.Privid,
                                    a.IsToolBar,
                                    a.BarOrder,
                                    a.BarCaption,
                                    b.NodeName,
                                    b.ParentNode,
                                    b.PluginId,
                                    b.CommentAry,
                                    b.Disporder,
                                    b.Type,
                                    b.GroupByName,
                                    b.ImageIco,
                                    b.TypeShow
                                };
                if (query.Any())
                {
    
                    list.AddRange(query.ToList().Select(item => new FindRoleRigthByRole
                    {
                        BarCaption = item.BarCaption,
                        BarOrder = item.BarOrder,
                        CommentAry = item.CommentAry,
                        IsEndNode = item.IsEndNode,
                        IsToolBar = item.IsToolBar,
                        NodeID = item.NodeID,
                        NodeName = item.NodeName,
                        ParentNode1 = item.ParentNode1,
                        ParentNode = item.ParentNode,
                        PluginId = item.PluginId,
                        Privid = item.Privid,
                        GroupByName = item.GroupByName,
                        ImageIco = item.ImageIco,
                        TypeShow = item.TypeShow,
                        Disporder = item.Disporder
                    }));
    
    
                }
                return list;
            }
    
            public List<T_Role> GetRoleAllList()
            {
                try
                {
                    return (from fx in _dbContext.T_Role select fx).ToList();
                }
                catch (EntityException ex)
                {
    
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
    
            }
    
            public int GetMaxRoleId()
            {
    
    
                try
                {
                    const string strsql = "select max(Convert(int,Roleid)) from T_Role";
                    return _dbContext.Database.SqlQuery<int>(strsql).FirstOrDefault();
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
    
            }
            #endregion
    用户角色
    #region 用户角色权限管理
    
            public void InsertTRolePrivilege(T_Role_Privilege roleEntity)
            {
    
                // _enity.Attach(roleEntity);
                try
                {
                    _dbContext.T_Role_Privilege.Add(roleEntity);
                    //  _enity.ObjectStateManager.ChangeObjectState(roleEntity, EntityState.Added);
                    _dbContext.SaveChanges();
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
    
            }
    
            public void DeleteRolePrivilegeByRoleId(string roleid)
            {
                try
                {
                    _dbContext.Database.ExecuteSqlCommand("delete from T_Role_Privilege where roleid=@roleid", new SqlParameter("@roleid", roleid));
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
            }
    
            public bool AddProjectLimits(List<T_ProjectLimits> projectLimitses, string typeinfo, string typeid)
            {
                try
                {
                    switch (typeinfo)
                    {
                        case "Operator":
                            string strsql = "delete from T_ProjectLimits where F_OperatorID=@Opid";
                            SqlParameter[] parms = new SqlParameter[]
                            {
                                new SqlParameter("@Opid", typeid)
                            };
                            _dbContext.Database.ExecuteSqlCommand(strsql, parms);
                            _dbContext.Set<T_ProjectLimits>().AddRange(projectLimitses);
                            break;
                        case "Role":
                            string sqlrole = "delete from T_ProjectLimits where F_RoleId=@Opid";
                            SqlParameter[] parmsrole = new SqlParameter[]
                            {
                                new SqlParameter("@Opid", typeid)
                            };
                            _dbContext.Database.ExecuteSqlCommand(sqlrole, parmsrole);
    
                            //获取该角色的操作员
                            DataTable opDt = Untity.ListToDataTable(GetToperatorsByRoleId(typeid));
                            if (opDt.Rows.Count > 0)
                            {
                                foreach (DataRow rows in opDt.Rows)
                                {
                                    string strsqloperator = "delete from T_ProjectLimits where F_OperatorID=@optUser";
                                    SqlParameter[] parmsoperator = new SqlParameter[]
                                            {
                                                new SqlParameter("@optUser", rows["OperatorId"])
                                            };
                                    _dbContext.Database.ExecuteSqlCommand(strsqloperator, parmsoperator);
                                }
                            }
    
                            foreach (var item in projectLimitses)
                            {
                                //添加角色信息
                                item.F_RoleId = typeid;
                                item.F_OperatorID = "";
                                _dbContext.Set<T_ProjectLimits>().Add(item);
                                foreach (DataRow rows in opDt.Rows)
                                {
                                    T_ProjectLimits  tp=new T_ProjectLimits()
                                    {
                                        F_ItemKey = item.F_ItemKey,
                                        F_ItemText = item.F_ItemText,
                                        F_OperatorID = rows["OperatorId"].ToString(),
                                        F_RoleId = typeid,
                                        F_SortId = item.F_SortId
                                    };                
                                   _dbContext.Set<T_ProjectLimits>().Add(tp);
                                }
                            }
                            break;
                    }
                    _dbContext.SaveChanges();
                    return true;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException exception)
                {
                    throw exception.InnerException;
                }
            }
    
            public bool AddOrgizationLimits(List<T_Organization_Privilege> organizationPrivileges, string typeinfo, string typeid)
            {
                try
                {
                    switch (typeinfo)
                    {
                        case "Operator":
                            string strsql = "delete from T_Organization_Privilege where F_OperatorId=@Opid";
                            SqlParameter[] parms = new SqlParameter[]
                            {
                                new SqlParameter("@Opid", typeid)
                            };
                            _dbContext.Database.ExecuteSqlCommand(strsql, parms);
                            _dbContext.Set<T_Organization_Privilege>().AddRange(organizationPrivileges);
                            break;
                        case "Role":
                            string sqlrole = "delete from T_Organization_Privilege where F_RoleId=@Opid";
                            SqlParameter[] parmsrole = new SqlParameter[]
                            {
                                new SqlParameter("@Opid", typeid)
                            };
                            _dbContext.Database.ExecuteSqlCommand(sqlrole, parmsrole);
    
                            //获取该角色的操作员
                            DataTable opDt = Untity.ListToDataTable(GetToperatorsByRoleId(typeid));
                            if (opDt.Rows.Count > 0)
                            {
                                foreach (DataRow rows in opDt.Rows)
                                {
                                    string strsqloperator = "delete from T_Organization_Privilege where F_OperatorId=@optUser";
                                    SqlParameter[] parmsoperator = new SqlParameter[]
                                            {
                                                new SqlParameter("@optUser", rows["OperatorId"])
                                            };
                                    _dbContext.Database.ExecuteSqlCommand(strsqloperator, parmsoperator);
                                }
                            }
    
                            foreach (var item in organizationPrivileges)
                            {
                                //添加角色信息
                                item.F_OperatorId = "";
                                item.F_RoleId = typeid;
                                _dbContext.Set<T_Organization_Privilege>().Add(item);
                                foreach (DataRow rows in opDt.Rows)
                                {
                                    T_Organization_Privilege tOrg=new T_Organization_Privilege()
                                    {
                                        F_KeyId = item.F_KeyId,
                                        F_OperatorId = rows["OperatorId"].ToString(),
                                        F_OrgID = item.F_OrgID,
                                        F_OrgName = item.F_OrgName,
                                        F_RoleId = typeid,
                                        F_ParentId = item.F_ParentId
                                    };
                                    _dbContext.Set<T_Organization_Privilege>().Add(tOrg);
                                }
                            }
                            break;
                    }
                    _dbContext.SaveChanges();
                    return true;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException exception)
                {
                    throw exception.InnerException;
                }
            }
    
            public bool AddLineMileageLimits(List<LineMileage_Privilege> organizationPrivileges, string typeinfo, string typeid)
            {
                try
                {
                    switch (typeinfo)
                    {
                        case "Operator":
                            string strsql = "delete from LineMileage_Privilege where OperatorId=@Opid";
                            SqlParameter[] parms = new SqlParameter[]
                            {
                                new SqlParameter("@Opid", typeid)
                            };
                            _dbContext.Database.ExecuteSqlCommand(strsql, parms);
                            _dbContext.Set<LineMileage_Privilege>().AddRange(organizationPrivileges);
                            _dbContext.SaveChanges();
                            break;
                        case "Role":
                            string sqlrole = "delete from LineMileage_Privilege where RoleId=@Opid";
                            SqlParameter[] parmsrole = new SqlParameter[]
                            {
                                new SqlParameter("@Opid", typeid)
                            };
                            _dbContext.Database.ExecuteSqlCommand(sqlrole, parmsrole);
    
                            //获取该角色的操作员
                            DataTable opDt = Untity.ListToDataTable(GetToperatorsByRoleId(typeid));
                            if (opDt.Rows.Count > 0)
                            {
                                foreach (DataRow rows in opDt.Rows)
                                {
                                    string strsqloperator = "delete from LineMileage_Privilege where OperatorId=@optUser";
                                    SqlParameter[] parmsoperator = new SqlParameter[]
                                    {
                                        new SqlParameter("@optUser", rows["OperatorId"])
                                    };
                                    _dbContext.Database.ExecuteSqlCommand(strsqloperator, parmsoperator);
                                }
                            }
    
                            foreach (var item in organizationPrivileges)
                            {
                                //添加角色信息
                                item.RoleId = typeid;
                                item.OperatorId = "";
                                _dbContext.Set<LineMileage_Privilege>().Add(item);
                                foreach (DataRow rows in opDt.Rows)
                                {
                                    LineMileage_Privilege line = new LineMileage_Privilege()
                                    {
                                        MileageId = item.MileageId,
                                        MileageName = item.MileageName,
                                        NodeId = item.NodeId,
                                        OperatorId = rows["OperatorId"].ToString(),
                                        RoleId = typeid
                                      
                                    };
                                    _dbContext.Set<LineMileage_Privilege>().Add(line);
                                }
                            }
                            _dbContext.SaveChanges();
                            break;
                    }
                 
                    return true;
                }
                catch (DbEntityValidationException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException exception)
                {
                    throw exception.InnerException;
                }
            }
    
            #endregion
    用户角色权限管理
    #region 菜单管理
    
            public void InsertTWholemenu(T_WholeMenu menuEntity)
            {
    
                try
                {
                    _dbContext.Set<T_WholeMenu>().Add(menuEntity);
                    _dbContext.SaveChanges();
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
    
    
            }
    
            public bool UpdateTWholeMenu(T_WholeMenu menuEntity)
            {
                try
                {
    
                    var category = _dbContext.T_WholeMenu.FirstOrDefault(o => o.NodeId == menuEntity.NodeId);
                    if (category != null)
                    {
                        category.NodeId = menuEntity.NodeId;
                        category.NodeName = menuEntity.NodeName;
                        category.ParentNode = menuEntity.ParentNode;
                        category.IsEndNode = menuEntity.IsEndNode;
                        category.PluginId = menuEntity.PluginId;
                        category.CommentAry = menuEntity.CommentAry;
                        category.Disporder = menuEntity.Disporder;
                        category.Type = menuEntity.Type;
                        category.GroupByName = menuEntity.GroupByName;
                        category.ImageIco = menuEntity.ImageIco;
                        category.TypeShow = menuEntity.TypeShow;
                        category.IsStartUp = menuEntity.IsStartUp;
                    }
                    _dbContext.SaveChanges();
    
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
                return true;
            }
    
            public List<T_WholeMenu> GetAllWholeMenuList()
            {
                try
                {
                    var query = from fx in _dbContext.T_WholeMenu select fx;
                    return query.ToList();
                }
                catch (EntityException ex)
                {
                    LogHelper.Error("GetAllWholeMenuList",ex);
                    throw ex.InnerException;
                }
               
    
            }
    
            public int GetTwholeMenuNodeId()
            {
                try
                {
                    var category = _dbContext.T_WholeMenu.Where(o => o.NodeId.Length == 2).Max(o => o.NodeId);
                    return Convert.ToInt32(category);
                }
                catch (EntityException ex)
                {
                    LogHelper.Error("GetTwholeMenuNodeId", ex);
                    throw ex.InnerException;
                }
               
    
            }
    
            public int GetTWholeMenuNodeChildrenId()
            {
                try
                {
                    var category = _dbContext.T_WholeMenu.Where(o => o.NodeId.Length > 3).Max(o => o.NodeId);
                    return Convert.ToInt32(category);
                }
                catch (EntityException ex)
                {
                    LogHelper.Error("GetTWholeMenuNodeChildrenId", ex);
                    throw ex.InnerException;
                }
               
    
            }
    
            public int GetMaxWholeMenuId(string parentnode)
            {
                try
                {
                    var category = _dbContext.T_WholeMenu.Where
                                 (o => o.ParentNode == parentnode).Max(o => o.NodeId);
                    return Convert.ToInt32(category);
                }
                catch (EntityException ex)
                {
                    LogHelper.Error("GetMaxWholeMenuId", ex);
                    throw ex.InnerException;
                }
             
    
            }
    
            //多级菜单删除
            public void DeleteWholeMenu(string parentid)
            {
                try
                {
                    var catetory = _dbContext.T_WholeMenu.Where(o => o.ParentNode == parentid);
                    if (catetory.Any())
                    {
                        foreach (var item in catetory)
                        {
                            T_WholeMenu itemTwhole = item;
                            var queryReslut = _dbContext.T_WholeMenu.Where(o => o.ParentNode == itemTwhole.NodeId);//查询该菜单下面是否有子菜单
                            if (queryReslut.Any())
                            {
                                foreach (var wholeMenu in queryReslut)
                                {
                                    T_WholeMenu menu = wholeMenu;
                                    var queryRm = _dbContext.T_WholeMenu.Where(o => o.ParentNode == menu.NodeId);
                                    if (queryRm.Any())
                                    {
                                        foreach (var itemMenu in queryRm)
                                        {
                                            _dbContext.T_WholeMenu.Remove(itemMenu);
                                        }
                                    }
                                    _dbContext.T_WholeMenu.Remove(wholeMenu);
                                }
                            }
                            _dbContext.T_WholeMenu.Remove(item);
    
                        }
                        _dbContext.SaveChanges();
                    }
                }
                catch (InvalidOperationException e)
                {
                    Console.WriteLine(e);
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
    
            }
    
            public void DeleteWholeMenuNode(string nodeid)
            {
    
                try
                {
                    var catetory = _dbContext.T_WholeMenu.Where(o => o.NodeId == nodeid);
                    if (catetory.Any())
                    {
                        foreach (var item in catetory)
                        {
                            _dbContext.Set<T_WholeMenu>().Attach(item);
                            _dbContext.Set<T_WholeMenu>().Remove(item);
                        }
                        _dbContext.SaveChanges();
                    }
                }
                catch (InvalidOperationException e)
                {
                    Console.WriteLine(e);
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
    
            }
    
            /// <summary>
            /// 保存用户权限
            /// </summary>
            /// <param name="dt">DataTable 数据源</param>
            /// <param name="type">类型</param>
            /// <param name="typeid">RoleId或OperatorId</param>
            /// <returns></returns>
            public bool AddUserRight(DataTable dt, string type, string typeid)
            {
                try
                {
                    switch (type)
                    {
                        #region Role
    
                        case "Role":
                            //删除该角色所有的权限
                            DeleteRolePrivilegeByRoleId(typeid);
                            _dbContext.Sys_Button_Privilege.RemoveRange(_dbContext.Sys_Button_Privilege.Where(o => o.RoleId == typeid));
                            _dbContext.SaveChanges();
                            //获取该角色的操作员
                            DataTable opDt = Untity.ListToDataTable(GetToperatorsByRoleId(typeid));
                            if (opDt.Rows.Count > 0)
                            {
                                foreach (DataRow row in opDt.Rows)
                                {
                                    //删除该角色对应操作员权限信息
                                    DeleteOperatorPrivilegeInfoByOperatorId(row["OperatorId"].ToString());
                                    RemoveSysButtonsPrivilege(row);
                                }
                            }
    
                            foreach (DataRow roleRow in dt.Select(" Isendnode='menu'"))
                            {
                                if (roleRow.RowState == DataRowState.Deleted)
                                    continue;
                                //创建对象
    
                                var roleData = new T_Role_Privilege
                                {
                                    BarCaption = roleRow["NodeName"].ToString(),
                                    BarOrder = 0,
                                    IsEndNode = roleRow["IsendNode"].ToString(),
                                    NodeID = roleRow["NodeId"].ToString(),
                                    ParentNode = roleRow["ParentNode"].ToString(),
                                    Privid = roleRow["NodeId"].ToString(),
                                    RoleId = typeid,
                                    IsToolBar = 0
                                };
                                //插入新的角色权限信息
                                // rolePrivilege.InsertTRolePrivilege(roleData);
                                InsertTRolePrivilege(roleData);
    
                                foreach (DataRow opRow in opDt.Rows)
                                {
    
                                    var operData = new T_Operator_Privilege
                                    {
                                        BarCaption = roleRow["NodeName"].ToString(),
                                        BarOrder = 0,
                                        IsEndNode = roleRow["IsendNode"].ToString(),
                                        NodeId = roleRow["NodeId"].ToString(),
                                        ParentNode = roleRow["ParentNode"].ToString(),
                                        PrivId = roleRow["NodeId"].ToString(),
                                        OperatorID = opRow["Operatorid"].ToString(),
                                        IsToolBar = 0
                                    };
                                    //插入新的该角色操作员权限信息
                                    InsertOperatorPrivilegeInfo(operData);
                                }
    
                            }
    
                            foreach (DataRow rows in dt.Select(" Isendnode='button'"))
                            {
                                if (rows.RowState == DataRowState.Deleted)
                                    continue;
    
                                //newRow["Nodeid"] = rowbutton.KeyId;
                                //newRow["ParentNode"] = rowbutton.MenuId;
                                //newRow["NodeName"] = rowbutton.ButtonCaption;
                                //newRow["Isendnode"] = "button";
                                //newRow["Disporder"] = rowbutton.ButtonId;
                                var opData = new Sys_Button_Privilege();
                                if (rows["Disporder"] != null)
                                {
                                    opData.ButtonId = Convert.ToInt32(rows["Disporder"]);
                                }
    
                                opData.RoleId = typeid;
                                string nodeid = rows["Nodeid"].ToString();
                                if (nodeid.Length == 1)
                                {
                                    nodeid = nodeid.PadLeft(2, '0');
                                }
                                opData.NodeId = nodeid;
                                _dbContext.Set<Sys_Button_Privilege>().Add(opData);
    
                                foreach (DataRow opRow in opDt.Rows)
                                {
    
                                    var opData2 = new Sys_Button_Privilege();
                                    if (rows["Disporder"] != null)
                                    {
                                        opData2.ButtonId = Convert.ToInt32(rows["Disporder"]);
                                    }
                                    opData2.RoleId = typeid;
                                    opData2.OperatorId = opRow["OperatorId"].ToString();
                                    opData2.NodeId = nodeid;
                                    _dbContext.Set<Sys_Button_Privilege>().Add(opData2);
    
                                }
    
                            }
                            _dbContext.SaveChanges();
                            break;
    
                        #endregion
    
                        #region Operator
    
                        case "Operator":
                            //删除该操作员权限信息
                            try
                            {
                                DeleteOperatorPrivilegeInfoByOperatorId(typeid);
                                _dbContext.Sys_Button_Privilege.RemoveRange(
                                    _dbContext.Sys_Button_Privilege.Where(o => o.OperatorId == typeid));
                                _dbContext.SaveChanges();
                            }
                            catch (Exception)
                            {
                                return false;
                            }
                            foreach (DataRow rows in dt.Select(" Isendnode='menu'"))
                            {
                                if (rows.RowState == DataRowState.Deleted)
                                    continue;
                                var opData = new T_Operator_Privilege
                                {
                                    BarCaption = rows["NodeName"].ToString(),
                                    BarOrder = 0,
                                    IsEndNode = rows["Isendnode"].ToString(),
                                    IsToolBar = 0,
                                    NodeId = rows["Nodeid"].ToString(),
                                    ParentNode = rows["Parentnode"].ToString(),
                                    PrivId = rows["Nodeid"].ToString(),
                                    OperatorID = typeid
                                };
                                //插入该操作员权限信息
                                InsertOperatorPrivilegeInfo(opData);
                            }
    
                            foreach (DataRow rows in dt.Select(" Isendnode='button'"))
                            {
                                if (rows.RowState == DataRowState.Deleted)
                                    continue;
    
                                //newRow["Nodeid"] = rowbutton.KeyId;
                                //newRow["ParentNode"] = rowbutton.MenuId;
                                //newRow["NodeName"] = rowbutton.ButtonCaption;
                                //newRow["Isendnode"] = "button";
                                //newRow["Disporder"] = rowbutton.ButtonId;
                                var opData = new Sys_Button_Privilege();
                                if (rows["Disporder"] != null)
                                {
                                    opData.ButtonId = Convert.ToInt32(rows["Disporder"]);
                                }
                                opData.OperatorId = typeid;
                                string nodeid = rows["Nodeid"].ToString();
                                if (nodeid.Length == 1)
                                {
                                    nodeid = nodeid.PadLeft(2, '0');
                                }
                                opData.NodeId = nodeid;
                                _dbContext.Set<Sys_Button_Privilege>().Add(opData);
                            }
                            _dbContext.SaveChanges();
                            break;
    
                        #endregion
    
                    }
                }
                catch (EntitySqlException)
                {
                    return false;
                }
                catch (InvalidOperationException)
                {
                    return false;
                }
                catch (EntityException)
                {
                    return false;
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
                return true;
    
            }
    
            private void RemoveSysButtonsPrivilege(DataRow row)
            {
                try
                {
                    string operatorId = row["OperatorId"].ToString();
                    var query = _dbContext.Sys_Button_Privilege.Where(o => o.OperatorId == operatorId);
                    if (query.Any())
                    {
                        _dbContext.Sys_Button_Privilege.RemoveRange(query);
                        _dbContext.SaveChanges();
                    }
                }
                catch (EntityException ex)
                {
                    LogHelper.Error("RemoveSysButtonsPrivilege", ex);
                    throw ex.InnerException;
                }
              
            }
    
            #endregion
    菜单管理
    #region 系统字典
    
            public bool InsertDectionary(T_DictionaryInfo tInfo)
            {
                try
                {
                    if (!_dbContext.Set<T_DictionaryInfo>().Any(o => o.F_DictonaryCode == tInfo.F_DictonaryCode))
                    {
                        _dbContext.Set<T_DictionaryInfo>().Add(tInfo);
                        _dbContext.SaveChanges();
                        return true;
                    }
                }
                catch (UpdateException e)
                {
                    throw e.InnerException;
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
                return false;
            }
    
            public bool UpdateDectionary(T_DictionaryInfo tInfo)
            {
                try
                {
    
                    var catetory = _dbContext.T_DictionaryInfo.First(o => o.F_DictonaryCode == tInfo.F_DictonaryCode);
                    catetory.F_DictonaryCode = tInfo.F_DictonaryCode;
                    catetory.F_DictonaryCoding = tInfo.F_DictonaryCoding;
                    catetory.F_DictonaryName = tInfo.F_DictonaryName;
                    catetory.F_DictonaryType = tInfo.F_DictonaryType;
                    catetory.F_ParentDictonaryCode = tInfo.F_ParentDictonaryCode;
                    catetory.F_Remark = tInfo.F_Remark;
                    _dbContext.SaveChanges();
    
                }
                catch (UpdateException exception)
                {
    
                    throw exception.InnerException;
                }
                catch (EntityException exception)
                {
                    throw exception.InnerException;
                }
                catch (Exception exception)
                {
    
                    throw exception.InnerException;
                }
                return true;
            }
    
            public List<T_DictionaryInfo> GetAllDictonaryList()
            {
                try
                {
    
                    List<T_DictionaryInfo> list = (from dictionaryInfo in _dbContext.T_DictionaryInfo select dictionaryInfo).ToList();
                    return list;
    
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
            }
    
            public List<T_DictionaryInfo> SearchDictionaryOfType(string fDictonaryCode)
            {
                var list = new List<T_DictionaryInfo>();
                try
                {
                    if (!string.IsNullOrEmpty(fDictonaryCode))
                    {
    
                        list = (from dictionaryInfo in _dbContext.T_DictionaryInfo where dictionaryInfo.F_ParentDictonaryCode == fDictonaryCode select dictionaryInfo).ToList();
                        return list;
    
                    }
    
                }
                catch (UpdateException e)
                {
                    throw e.InnerException;
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
                return list;
            }
    
            public List<T_DictionaryInfo> SearchDictionaryOfTypeCode(string typeCode)
            {
                List<T_DictionaryInfo>  list=new List<T_DictionaryInfo>();
                try
                {
                    if (!string.IsNullOrEmpty(typeCode))
                    {
                      T_DictionaryInfo  tDictionaryInfo= _dbContext.T_DictionaryInfo.FirstOrDefault(o=>o.F_DictonaryType==typeCode);
                        if (tDictionaryInfo != null)
                        {
                            list = SearchDictionaryOfType(tDictionaryInfo.F_DictonaryCode);
                        }
                    }
                }
                catch (UpdateException e)
                {
                    throw e.InnerException;
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
                return list;
            }
            public int GetMaxDictionaryParentCode()
            {
                try
                {
    
                    var category = _dbContext.T_DictionaryInfo.Where(o => o.F_DictonaryCode.Length == 2).Max(o => o.F_DictonaryCode);
                    return Convert.ToInt32(category);
    
                }
                catch (UpdateException e)
                {
                    throw e.InnerException;
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
            }
    
            public int GetDictionaryNodeChildrenCode()
            {
                try
                {
    
                    var category = _dbContext.T_DictionaryInfo.Where(o => o.F_DictonaryCode.Length > 3).Max(o => o.F_DictonaryCode);
                    return Convert.ToInt32(category);
    
                }
                catch (UpdateException e)
                {
                    throw e.InnerException;
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
            }
    
            public int GetMaxDictionaryCode(string parentCode)
            {
                try
                {
    
                    var category = _dbContext.T_DictionaryInfo.Where
                        (o => o.F_ParentDictonaryCode == parentCode).Max(o => o.F_DictonaryCode);
                    return Convert.ToInt32(category);
    
                }
                catch (UpdateException e)
                {
                    throw e.InnerException;
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
            }
    
            public bool DeleteDictionaryChildrenCode(string dictonaryCode)
            {
                try
                {
    
    
                    var catetory = _dbContext.T_DictionaryInfo.Where(o => o.F_DictonaryCode == dictonaryCode);
                    if (catetory.Any())
                    {
                        foreach (var item in catetory)
                        {
                            _dbContext.Set<T_DictionaryInfo>().Attach(item);
                            _dbContext.Set<T_DictionaryInfo>().Remove(item);
    
                        }
                        _dbContext.SaveChanges();
                    }
    
    
                }
                catch (UpdateException e)
                {
                    throw e.InnerException;
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
    
                return true;
            }
    
            public bool DeleteDictonaryCode(string parnentdictonaryCode)
            {
                try
                {
    
                    var catetory = _dbContext.T_DictionaryInfo.Where(o => o.F_ParentDictonaryCode == parnentdictonaryCode);
                    if (catetory.Any())
                    {
                        foreach (var item in catetory)
                        {
                            _dbContext.Set<T_DictionaryInfo>().Attach(item);
                            _dbContext.Set<T_DictionaryInfo>().Remove(item);
                        }
                        _dbContext.SaveChanges();
                    }
    
                }
                catch (UpdateException)
                {
                    return false;
                }
                catch (EntityException)
                {
                    return false;
                }
                catch (Exception)
                {
    
                    return false;
                }
                return true;
            }
    
            public DataTable GetAllTableNameByDb(string dataBaseName)
            {
                try
                {
    
    
                    var retVal = new DataTable();
                    var sqlConn = (SqlConnection)_dbContext.Database.Connection;
                    var cmdReport = new SqlCommand(string.Format("SELECT Name FROM {0}..SysObjects Where XType='U' ORDER BY Name", dataBaseName), sqlConn);
                    var daReport = new SqlDataAdapter(cmdReport);
                    using (cmdReport)
                    {
                        daReport.Fill(retVal);
                    }
                    retVal.TableName = "SystemTableName";
                    return retVal;
    
                }
                catch (UpdateException e)
                {
                    throw e.InnerException;
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
    
            }
    
            public int GetDictionaryCountByParentCode(string parentCode)
            {
                try
                {
    
                    var category = _dbContext.T_DictionaryInfo.Count(o => o.F_ParentDictonaryCode == parentCode);
                    return Convert.ToInt32(category);
    
                }
                catch (UpdateException e)
                {
                    throw e.InnerException;
                }
                catch (Exception ee)
                {
                    throw ee.InnerException;
                }
            }
    
            public T_DictionaryInfo GetTDictonaryInfo(string dictonaryCode)
            {
    
                var query = (from fx in _dbContext.T_DictionaryInfo where fx.F_DictonaryCode.Equals(dictonaryCode) select fx).FirstOrDefault();
                return query;
    
    
            }
    
            #endregion
    系统字典
     #region 机构
            ///<summary>
            ///新增操作T_Organization 
            /// </summary>
            public bool InsertT_Organization(T_Organization model,string operatorId)
            {
                try
                {
                    _dbContext.Set<T_Organization>().Add(model);
                   
                    //插入权限
                    _dbContext.Set<T_Organization_Privilege>().Add(new T_Organization_Privilege()
                    {
                        F_OperatorId =operatorId,
                        F_OrgID = model.F_OrgID,
                        F_OrgName = model.F_OrgName,
                        F_ParentId = model.F_ParentID
                    });
                    if (operatorId != "10000")
                    {
                        //插入超级管理员的权限
                        _dbContext.Set<T_Organization_Privilege>().Add(new T_Organization_Privilege()
                        {
                            F_OperatorId = "10000",
                            F_OrgID = model.F_OrgID,
                            F_OrgName = model.F_OrgName,
                            F_ParentId = model.F_ParentID
                        });  
                    }
    
                
                    _dbContext.SaveChanges();
    
                }
                catch (EntityException)
                {
                    return false;
                }
                catch (Exception)
                {
                    return false;
                }
                return true;
            }
    
            ///<summary>
            ///修改操作T_Organization 
            /// </summary>
            public bool UpdateT_Organization(T_Organization model)
            {
                try
                {
    
                    var category = _dbContext.T_Organization.FirstOrDefault(o => o.F_OrgID == model.F_OrgID);
                    if (category != null)
                    {
                        category.F_OrgID = model.F_OrgID;
                        category.F_OrgName = model.F_OrgName;
                        category.F_OrgManager = model.F_OrgManager;
                        category.F_BuildDate = model.F_BuildDate;
                        category.F_BuildMan = model.F_BuildMan;
                        category.F_TellPhoneNum = model.F_TellPhoneNum;
                        category.F_Address = model.F_Address;
                        category.F_ParentID = model.F_ParentID;
                        category.F_State = model.F_State;
                    }
    
                    //  _enity.Entry(.State = EntityState.Modified;
                    _dbContext.Entry(category).State = EntityState.Modified;
                    //修改权限表
                    var privialeages = _dbContext.T_Organization_Privilege.Where(o => o.F_OrgID == model.F_OrgID);
                    if (privialeages.Any())
                    {
                        foreach (T_Organization_Privilege privialeage in privialeages)
                        {
                            privialeage.F_OrgName = model.F_OrgName;
                        }
                    }
                    _dbContext.SaveChanges();
    
                }
                catch (EntityException)
                {
                    return false;
                }
                catch (Exception)
                {
                    return false;
                }
                return true;
            }
    
            ///<summary>
            ///删除操作T_Organization 
            /// </summary>
            public bool DeleteT_Organization(string modelCode)
            {
                try
                {
    
                    var category = _dbContext.T_Organization.Where(o => o.F_OrgID == modelCode);
                    if (category.Any())
                    {
                        foreach (T_Organization item in category)
                        {
                            _dbContext.Set<T_Organization>().Attach(item);
                            _dbContext.Set<T_Organization>().Remove(item);
                        }
                        _dbContext.SaveChanges();
                    }
                    //删除权限表里面的信息
                    var privleages = _dbContext.T_Organization_Privilege.Where(o => o.F_OrgID == modelCode);
                    if (privleages.Any())
                    {
                        foreach (T_Organization_Privilege organization in privleages)
                        {
                            _dbContext.Set<T_Organization_Privilege>().Attach(organization);
                            _dbContext.Set<T_Organization_Privilege>().Remove(organization);   
                        }
    
                        _dbContext.SaveChanges();
                    }
    
                }
                catch (EntityException)
                {
                    return false;
                }
                catch (Exception)
                {
                    return false;
                }
                return true;
            }
            ///<summary>
            ///获取所有数据T_Organization 
            /// </summary>
            public List<T_Organization> GetT_OrganizationListData()
            {
                try
                {
    
                    return _dbContext.T_Organization.ToList();
    
                }
                catch (EntityException exception)
                {
                    throw exception.InnerException;
                }
                catch (Exception exception)
                {
                    throw exception.InnerException;
                }
            }
    
            public IQueryable<T_Organization> GetT_OrganizationBy(string operatorId)
            {
                try
                {
                    var query = _dbContext.T_Organization.Where(o => o.F_OrgID == operatorId);
                    return query;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            #endregion
    组织机构
     #region 机构数据权限
    
            /// <summary>
            ///根据SQL语句查询返回IQueryableT_Organization_Privilege
            /// <param name="strsql">T_Organization_PrivilegeSQL语句</param>
            /// </summary>
            public IQueryable<T_Organization_Privilege> GetT_Organization_PrivilegeBySql(string strsql, params object[] obj)
            {
                try
                {
                    IQueryable<T_Organization_Privilege> iQueryable = _dbContext.Database.SqlQuery<T_Organization_Privilege>(strsql, obj).AsQueryable();
                    return iQueryable;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            public List<T_Organization_Privilege> GetT_Organization_PrivilegeById(string id)
            {
                try
                {
                    return _dbContext.Set<T_Organization_Privilege>().Where(o => o.F_OperatorId == id).ToList();
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message);
                    throw ex.InnerException;
                }
                catch (DbException exception)
                {
                    LogHelper.Error(exception.Message);
                    throw exception.InnerException;
                }
            }
    
            public bool UpdateT_Organization_Privilege(List<T_Organization_Privilege> entity)
            {
                try
                {
                    foreach (var operatorOrgPrivilege in entity)
                    {
                        new BaseDAL<T_Organization_Privilege>(_dbContext).Modify(operatorOrgPrivilege);
                    }
                    return true;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException exception)
                {
                    throw exception.InnerException;
                }
            }
            public bool CreateT_Organization_Privilege(List<T_Organization_Privilege> entity, string operatorId)
            {
                try
                {
                    string strsql = "delete from T_Organization_Privilege where F_OperatorId=@Opid";
                    SqlParameter[] parms = new SqlParameter[]{
                       new SqlParameter("@Opid",operatorId)
                    };
                    _dbContext.Database.ExecuteSqlCommand(strsql, parms);
                    foreach (var operatorOrgPrivilege in entity)
                    {
                        _dbContext.Set<T_Organization_Privilege>().Add(operatorOrgPrivilege);
                    }
                    _dbContext.SaveChanges();
                    return true;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException exception)
                {
                    throw exception.InnerException;
                }
            }
    
            public bool CreateT_Organization_PrivilegeEntity(T_Organization_Privilege entity)
            {
                try
                {
                    _dbContext.Set<T_Organization_Privilege>().Add(entity);
                    _dbContext.SaveChanges();
                    return true;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException exception)
                {
                    throw exception.InnerException;
                } 
            }
    
            public bool DeleteT_Organization_Privilege(List<int> id)
            {
                try
                {
                    foreach (var i in id)
                    {
                        new BaseDAL<T_Organization_Privilege>(_dbContext).DelBy(o => o.F_KeyId == i);
                    }
                    return true;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException exception)
                {
                    throw exception.InnerException;
                }
            }
    
            /// <summary>
            ///获取实体LineMileage_Privilege
            /// <param name="id">主键编号</param>
            /// </summary>
            public LineMileage_Privilege GetLineMileage_PrivilegeById(string id)
            {
                try
                {
                    return _dbContext.LineMileage_Privilege.FirstOrDefault(o => o.SysId == int.Parse(id));
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
    
                }
            }
    
            /// <summary>
            ///修改实体LineMileage_Privilege
            /// <param name="entity">LineMileage_Privilege实体</param>
            /// </summary>
            public bool UpdateLineMileage_Privilege(LineMileage_Privilege entity)
            {
                try
                {
                    var category = _dbContext.LineMileage_Privilege.FirstOrDefault(o => o.SysId == entity.SysId);
                    if (category != null)
                    {
                        category.SysId = entity.SysId;
                        category.NodeId = entity.NodeId;
                        category.OperatorId = entity.OperatorId;
                        category.MileageId = entity.MileageId;
                        _dbContext.SaveChanges();
                    }
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                return true;
            }
    
            /// <summary>
            ///新增实体LineMileage_Privilege
            /// <param name="entity">LineMileage_Privilege实体</param>
            /// </summary>
            public bool CreateLineMileage_Privilege(List<LineMileage_Privilege> entity, string operatorid)
            {
                try
                {
                    string strsql = "delete from LineMileage_Privilege where Operatorid=@Opid";
                    SqlParameter[] parms = new SqlParameter[]{
                       new SqlParameter("@Opid",operatorid)
                    };
                    _dbContext.Database.ExecuteSqlCommand(strsql, parms);
                    foreach (var item in entity)
                    {
                        _dbContext.Set<LineMileage_Privilege>().Add(item);
                        _dbContext.SaveChanges();
                    }
    
                    return true;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            /// <summary>
            ///删除LineMileage_Privilege
            /// <param name="id">主键编号SysId</param>
            /// </summary>
            public bool DeleteLineMileage_Privilege(string id)
            {
                try
                {
                    var category = _dbContext.LineMileage_Privilege.FirstOrDefault(o => o.SysId == int.Parse(id));
                    if (category != null)
                    {
                        _dbContext.Set<LineMileage_Privilege>().Attach(category);
                        _dbContext.Set<LineMileage_Privilege>().Remove(category);
                        _dbContext.SaveChanges();
                    }
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message);
                    throw ex.InnerException;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message);
                    throw ex.InnerException;
                }
    
                return true;
            }
    
            public IQueryable<T_ProjectLimits> GetT_ProjectLimitsBySql(string strsql, params object[] obj)
            {
                try
                {
                    IQueryable<T_ProjectLimits> iQueryable =
                        _dbContext.Database.SqlQuery<T_ProjectLimits>(strsql, obj).AsQueryable();
                    return iQueryable;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
    
            }
    
            /// <summary>
            ///根据SQL语句查询返回IQueryableLineMileage_Privilege
            /// <param name="strsql">LineMileage_PrivilegeSQL语句</param>
            /// </summary>
            public IQueryable<LineMileage_Privilege> GetLineMileage_PrivilegeBySql(string strsql, params CmdParameter[] obj)
            {
                try
                {
                    DbParameter[] parameters = new DbParameter[obj.Length];
                    for (int i = 0; i < obj.Length; i++)
                    {
                        DbParameter sqlPram = new SqlParameter(obj[i].ParameterName, obj[i].Value);
                        parameters[i] = sqlPram;
                    }
                    IQueryable<LineMileage_Privilege> iQueryable = _dbContext.Database.SqlQuery<LineMileage_Privilege>(strsql, parameters).AsQueryable();
                    return iQueryable;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            public bool CreateT_ProjectLimits_Privilege(List<T_ProjectLimits> entity, string operatorId)
            {
                try
                {
                    string strsql = "delete from T_ProjectLimits where F_OperatorID=@Opid";
                    SqlParameter[] parms = new SqlParameter[]{
                       new SqlParameter("@Opid",operatorId)
                    };
                    _dbContext.Database.ExecuteSqlCommand(strsql, parms);
                    foreach (var item in entity)
                    {
                        _dbContext.Set<T_ProjectLimits>().Add(item);
                    }
                    _dbContext.SaveChanges();
                    return true;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            public IQueryable<T_ProjectLimits> GetT_ProjectLimitsByOperator(string operatorid)
            {
                try
                {
                   
                    var query=_dbContext.T_ProjectLimits.Where(o => o.F_OperatorID == operatorid);
                    return query;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            #endregion bn
    机构数据权限
       #region 按钮服务
    
            /// <summary>
            ///获取实体Sys_Buttons
            /// <param name="id">主键编号</param>
            /// </summary>
            public Sys_Buttons GetSys_ButtonsById(int id)
            {
                try
                {
                    return _dbContext.Sys_Buttons.FirstOrDefault(o => o.KeyId == id);
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
    
                }
            }
    
            /// <summary>
            ///修改实体Sys_Buttons
            /// <param name="entity">Sys_Buttons实体</param>
            /// </summary>
            public bool UpdateSys_Buttons(Sys_Buttons entity)
            {
                try
                {
                    var category = _dbContext.Sys_Buttons.FirstOrDefault(o => o.KeyId == entity.KeyId);
                    if (category != null)
                    {
                        category.KeyId = entity.KeyId;
                        category.ButtonCaption = entity.ButtonCaption;
                        category.Sortnum = entity.Sortnum;
                        category.IconCls = entity.IconCls;
                        category.IconUrl = entity.IconUrl;
                        category.ButtonTag = entity.ButtonTag;
                        category.Remark = entity.Remark;
                        category.ButtonHtml = entity.ButtonHtml;
                        category.BuggonGroup = entity.BuggonGroup;
                        category.State = entity.State;
                        category.ToolTip = entity.ToolTip;
                        _dbContext.SaveChanges();
                    }
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                return true;
            }
    
            /// <summary>
            ///新增实体Sys_Buttons
            /// <param name="entity">Sys_Buttons实体</param>
            /// </summary>
            public bool CreateSys_Buttons(Sys_Buttons entity)
            {
                try
                {
                    _dbContext.Set<Sys_Buttons>().Add(entity);
                    _dbContext.SaveChanges();
                    return true;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            /// <summary>
            ///删除Sys_Buttons
            /// <param name="id">主键编号KeyId</param>
            /// </summary>
            public bool DeleteSys_Buttons(int id)
            {
                try
                {
                    var category = _dbContext.Sys_Buttons.FirstOrDefault(o => o.KeyId == id);
                    if (category != null)
                    {
                        _dbContext.Set<Sys_Buttons>().Attach(category);
                        _dbContext.Set<Sys_Buttons>().Remove(category);
                        _dbContext.SaveChanges();
                    }
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
    
                return true;
            }
    
            public IQueryable<Sys_WholeMenuButtons> GetSys_WholeMenuButtonsBySql(string sql, params CmdParameter[] obj)
            {
                try
                {
                    DbParameter[] parameters = new DbParameter[obj.Length];
                    for (int i = 0; i < obj.Length; i++)
                    {
                        DbParameter sqlPram = new SqlParameter(obj[i].ParameterName, obj[i].Value);
                        parameters[i] = sqlPram;
                    }
                    IQueryable<Sys_WholeMenuButtons> iQueryable = _dbContext.Database.SqlQuery<Sys_WholeMenuButtons>(sql, parameters).AsQueryable();
                    return iQueryable;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            /// <summary>
            ///根据SQL语句查询返回IQueryableSys_Buttons
            /// <param name="sql">Sys_ButtonsSQL语句</param>
            /// </summary>
            public IQueryable<Sys_Buttons> GetSys_ButtonsBySql(string strsql, params CmdParameter[] obj)
            {
                try
                {
                    DbParameter[] parameters = new DbParameter[obj.Length];
                    for (int i = 0; i < obj.Length; i++)
                    {
                        DbParameter sqlPram = new SqlParameter(obj[i].ParameterName, obj[i].Value);
                        parameters[i] = sqlPram;
                    }
                    IQueryable<Sys_Buttons> iQueryable = _dbContext.Database.SqlQuery<Sys_Buttons>(strsql, parameters).AsQueryable();
                    return iQueryable;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            public List<TWholeMenuButton> GetTWholeMenuButtons(string menuId)
            {
                try
                {
    
                    var query = (from fx in _dbContext.Sys_WholeMenuButtons
                                 join fb in _dbContext.Sys_Buttons
                                 on fx.ButtonId equals fb.KeyId
                                 where fx.MenuId == menuId
                                 select new TWholeMenuButton
                                 {
                                     KeyId = fx.KeyId,
                                     MenuId = fx.MenuId,
                                     Sortnum = fx.Sortnum,
                                     ButtonCaption = fb.ButtonCaption,
                                     IconCls = fb.IconCls
                                 }).ToList();
                    return query;
                }
                catch (FormatException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            public List<TWholeMenuButton> GetTWholeMenuButtonsAllList()
            {
                try
                {
    
                    var queryResult = (from fx in _dbContext.Sys_Buttons
                                       join dx in _dbContext.Sys_WholeMenuButtons on fx.KeyId equals dx.ButtonId
                                       select new TWholeMenuButton()
                                       {
                                           KeyId = dx.KeyId,
                                           ButtonCaption = fx.ButtonCaption,
                                           ButtonId = fx.KeyId,
                                           IconCls = fx.IconCls,
                                           MenuId = dx.MenuId,
                                           Sortnum = dx.Sortnum
                                       }).ToList();
                    return queryResult;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            public List<TWholeMenuButton> GetButtonLimitsAlList(string operatorId)
            {
                try
                {
                    var queryResult = (from db in _dbContext.Sys_Buttons
                                       join fx in _dbContext.Sys_Button_Privilege
                                           on db.KeyId equals fx.ButtonId
                                       where fx.OperatorId == operatorId
                                       select new TWholeMenuButton()
                                       {
                                           KeyId = db.KeyId,
                                           ButtonId = db.KeyId,
                                           MenuId = fx.NodeId,
                                           ButtonCaption = db.ButtonCaption,
                                           OperatorId = operatorId
                                       }).ToList();
                    return queryResult;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            public List<TWholeMenuButton> GetButtonLimitstRoleAllList(string roleId)
            {
                try
                {
                    var queryResult = (from db in _dbContext.Sys_Buttons
                                       join fx in _dbContext.Sys_Button_Privilege
                                           on db.KeyId equals fx.ButtonId
                                       where fx.RoleId == roleId
                                        && fx.OperatorId == null || fx.OperatorId == ""
                                       select new TWholeMenuButton()
                                       {
                                           KeyId = db.KeyId,
                                           ButtonId = db.KeyId,
                                           MenuId = fx.NodeId,
                                           ButtonCaption = db.ButtonCaption,
                                           RoleId = roleId
                                       }).ToList();
                    return queryResult;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            /// <summary>
            ///新增实体Sys_WholeMenuButtons
            /// <param name="entity">Sys_WholeMenuButtons实体</param>
            /// </summary>
            public bool CreateSys_WholeMenuButtons(List<Sys_WholeMenuButtons> entity)
            {
                try
                {
                    foreach (var item in entity)
                    {
                        _dbContext.Set<Sys_WholeMenuButtons>().Add(item);
                    }
                    _dbContext.SaveChanges();
                    return true;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            /// <summary>
            ///删除Sys_WholeMenuButtons
            /// <param name="nodeid">主键编号KeyId</param>
            /// </summary>
            public bool DeleteSys_WholeMenuButtons(string nodeid)
            {
                try
                {
                    var category = _dbContext.Sys_WholeMenuButtons.Where(o => o.MenuId == nodeid);
                    if (category.Any())
                    {
                        foreach (var item in category)
                        {
                            _dbContext.Set<Sys_WholeMenuButtons>().Attach(item);
                            _dbContext.Set<Sys_WholeMenuButtons>().Remove(item);
                        }
                    }
                    _dbContext.SaveChanges();
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
    
                return true;
            }
    
            public IQueryable<ProjectsLimits> GetProjectsLimitsesByOperator(string operatorId)
            {
                try
                {
                    var category = (from fx in _dbContext.T_ProjectLimits
                        join db in _dbContext.RbimProject
                            on fx.F_ItemKey equals db.ItemKey
                        where fx.F_OperatorID == operatorId
                        select new ProjectsLimits()
                        {
                             ProjectCode = db.ProjectCode,
                             ItemKey = db.ItemKey,
                             ItemText = fx.F_ItemText,
                             OperatorId = operatorId,
                             ProjectLocation = db.ProjectLocation,
                             ProjectRemark = db.ProjectRemark,
                             ProjectUrl = db.ProjectUrl,
                             RoleId = fx.F_RoleId,
                             SortId = fx.F_SortId
                        }).AsQueryable();
    
                    return category;
                }
                catch (EntityException ex)
                {
                    LogHelper.Error(ex.Message);
                   throw ex.InnerException;
                }
                catch (DbException ex)
                {
                   LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            public IEnumerable<LineMileageLimits> GetLineMileageLimitsesByOperator(string operatorId, string projectKey)
            {
                try
                {
                    var category = (from fx in _dbContext.LineMileage_Privilege
                        join db in _dbContext.LineMileages
                            on fx.MileageId equals db.MileageID.ToString()
                        where fx.NodeId == projectKey
                        && fx.OperatorId==operatorId
                        select new LineMileageLimits()
                        {
                            SysId = fx.SysId,
                            MileageId = fx.MileageId,
                            MileageName = fx.MileageName,
                            ProjectKey = fx.NodeId,
                            ModelSizes = db.ModelSizes,
                            ModelType = db.ModelType,
                            NodeType = db.NodeType,
                            OperatorId = fx.OperatorId,
                            ParentMileageId = db.ParentMileageID,
                            PlanPath = db.PlanPath,
                            SortId = db.SortId,
                            RelationModel = db.RelationModel,
                            SOidModelFile = db.SOidModelFile
    
                        }).AsEnumerable();
                    return category;
    
                }
                catch (EntityException ex)
                {
    
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
                catch (DbException ex)
                {
                    LogHelper.Error(ex.Message); throw ex.InnerException;
                }
            }
    
            #endregion
    按钮服务
      public void Dispose()
            {
                var dispose = _dbContext as IDisposable;
                if (dispose != null)
                {
                    _dbContext.Dispose();
                }
            }
        }

     4、WCF服务启动

      public void ServiceStart()
            {
                try
                {
    
                    string serviceport = ConfigurationManager.AppSettings["port"];// "8007";
                    string serviceIp = ConfigurationManager.AppSettings["serviceIp"];// "127.0.0.1";
                    string serviceAddress = string.Format("net.tcp://{0}:{1}", serviceIp, serviceport);
                    var sevtypes = new Dictionary<Type, Type>
                        {
                            {typeof (IOperationpurviewService), typeof (OperationService)}
                            
                        };
    
                    foreach (var item in sevtypes)
                    {
                        string tName = item.Key.Name.Substring(1);
                        string endpointAddress = serviceAddress + tName;
                        if (!serviceAddress.EndsWith("/"))
                            endpointAddress = string.Format("{0}/{1}", serviceAddress, tName);
                        var serviceHost = new ServiceHost(item.Value, new Uri(endpointAddress));
                        //加载元数据结点
                        var smb = new ServiceMetadataBehavior();
                        serviceHost.Description.Behaviors.Add(smb);
                         // serviceHost.Description.Behaviors.Add(new ServiceDebugBehavior(){IncludeExceptionDetailInFaults = true});
                        serviceHost.AddServiceEndpoint(typeof(IMetadataExchange),
                                                       MetadataExchangeBindings.CreateMexTcpBinding(), "mex");
                        //加载NetTcpBinding结点
                        var netTcpBinding = new NetTcpBinding
                        {
                            Security = { Mode = SecurityMode.None },
                            ReceiveTimeout = TimeSpan.Parse("10:59:00"),
                            CloseTimeout = TimeSpan.Parse("10:59:00"),
                            OpenTimeout = TimeSpan.Parse("10:59:00"),
                            SendTimeout = TimeSpan.Parse("10:59:00"),
                            MaxBufferPoolSize = long.MaxValue - 1,
                            MaxBufferSize = int.MaxValue - 1,
                            MaxReceivedMessageSize = int.MaxValue - 1,
                            //MaxConnections = 1000,
                            ReaderQuotas =
                            {
                                MaxDepth = int.MaxValue - 1,
                                MaxStringContentLength = int.MaxValue - 1,
                                MaxArrayLength = int.MaxValue - 1,
                                MaxBytesPerRead = int.MaxValue - 1,
                                MaxNameTableCharCount = int.MaxValue - 1
                            }
                            //  ,PortSharingEnabled = true //端口共享
                        };
                        serviceHost.AddServiceEndpoint(item.Key, netTcpBinding, endpointAddress);
                        string address = endpointAddress;
                        serviceHost.Opened += delegate
                        {
                            LoadPluginNameSpace.Add(new ServiceInfo() { Address = address + "/mex", Id = 0, State = "启动" });
                        };
    
                        serviceHost.Open();
                        ServiceHosts.Add(serviceHost);
                    }
                }
                catch (ConfigurationException e)
                {
                    Console.WriteLine(e);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }

    5、WCF 注册Windows服务

      internal class OperatorService : ServiceBase
        {
            private IContainer components = null;
            public ServiceHost serviceHost;
    
            public OperatorService()
            {
                this.InitializeComponent();
                base.ServiceName= "LU.ServiceModule.OperationService";
            }
    
            protected override void Dispose(bool disposing)
            {
                if (disposing && (this.components != null))
                {
                    this.components.Dispose();
                }
                base.Dispose(disposing);
            }
    
            private void InitializeComponent()
            {
                this.components = new Container();
                base.ServiceName = "LU.ServiceModule.OperationService";
            }
    
            protected override void OnStart(string[] args)
            {
                this.serviceHost = new ServiceHost(typeof(OperationService));
                ServiceMetadataBehavior item = new ServiceMetadataBehavior();
                this.serviceHost.Description.Behaviors.Add(item);
                this.serviceHost.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexTcpBinding(), "mex");
                this.serviceHost.Opened += (param0, param1) => LogHelper.Info("OperationService is Starting!!!");
                this.serviceHost.Open();
            }
    
            protected override void OnStop()
            {
                if (this.serviceHost != null)
                {
                    this.serviceHost.Abort();
                }
            }
        }
  • 相关阅读:
    ionic新手教程第三课-在项目中使用requirejs分离controller文件和server文件
    高并发測试工具webbench
    内存管理详解
    linux command ---1
    运维方面的软件(系统)
    配置 php-fpm 监听的socket
    FastCgi与PHP-fpm之间是个什么样的关系
    分表处理设计思想和实现
    PHP 命名空间以及自动加载(自动调用的函数,来include文件)
    javascript closure
  • 原文地址:https://www.cnblogs.com/w2011/p/11286229.html
Copyright © 2011-2022 走看看