public SecurityGrid(DotNetNuke.Entities.Portals.PortalSettings ps, bool isReadOnly, string imgPath, PermissionInfo sec, int permId)
		{
			PortalSettings = ps;
			ReadOnly = isReadOnly;
			ImagePath = imgPath;
			Security = sec;
			PermissionsId = permId;
		}

 public ModulePermissionInfo(PermissionInfo permission)
     : this()
 {
     this.ModuleDefID = permission.ModuleDefID;
     this.PermissionCode = permission.PermissionCode;
     this.PermissionID = permission.PermissionID;
     this.PermissionKey = permission.PermissionKey;
     this.PermissionName = permission.PermissionName;
 }

 /// <summary>
 /// 递归加载所有权限
 /// </summary>
 /// <param name="rootPermission"></param>
 /// <param name="permission"></param>
 private void AddPermissions(PermissionInfo rootPermission, Permission permission)
 {
     var permissions = PermissionInfos.Where(p => p.ParentName == rootPermission.Name);
     foreach (PermissionInfo permissionInfo in permissions)
     {
         var childernPermission = permission.CreateChildPermission(permissionInfo.Name,
               new FixedLocalizableString(permissionInfo.DisplayName), permissionInfo.IsGrantedByDefault);
         AddPermissions(permissionInfo, childernPermission);
     }
 }

 public void AddPermission(string principal, PermissionInfo permission)
 {
     if (HasPrincipal(principal))
     {
         if (!permissions.Keys.Contains(this[principal]))
             permissions.Add(this[principal], new PermissionInfoCollection());
         permissions[this[principal]].Add(permission);
     }
     else
         throw new ArgumentException("you must add " + principal + " user!");
 }

 public override bool Contains(PermissionInfo permission)
 {
     if (permission == null)
         return false;
     switch(LogicPoint)
     {
         case LogicPoint.AND:
         default:
             return left.Contains(permission) && right.Contains(permission);
         case LogicPoint.OR:
             return left.Contains(permission) || right.Contains(permission);
     }
 }

 public override bool Contains(PermissionInfo permission)
 {
     DefaultPermissionInfo tp = permission as DefaultPermissionInfo;
     if (tp == null)
         return false;
     if (!CompareName(tp))
     {
         return false;
     }
     else
     {
         return CompareAction(tp);
     }
 }

        /// <summary>
        /// Gets the Enabled status of the permission
        /// </summary>
        /// <param name="objPerm">The permission being loaded</param>
        /// <param name="role">The role</param>
        /// <param name="column">The column of the Grid</param>
        protected override bool GetEnabled( PermissionInfo objPerm, RoleInfo role, int column )
        {
            bool enabled;

            if( role.RoleID == AdministratorRoleId )
            {
                enabled = false;
            }
            else
            {
                enabled = true;
            }

            return enabled;
        }

 private ModulePermissionInfo AddModulePermission(ModuleInfo objModule, PermissionInfo permission, int roleId, int userId, bool allowAccess)
 {
     ModulePermissionInfo objModulePermission = new ModulePermissionInfo();
     objModulePermission.ModuleID = objModule.ModuleID;
     objModulePermission.PermissionID = permission.PermissionID;
     objModulePermission.RoleID = roleId;
     objModulePermission.UserID = userId;
     objModulePermission.PermissionKey = permission.PermissionKey;
     objModulePermission.AllowAccess = allowAccess;
     if (!objModule.ModulePermissions.Contains(objModulePermission))
     {
         objModule.ModulePermissions.Add(objModulePermission);
     }
     return objModulePermission;
 }

 public override bool Contains(PermissionInfo permission)
 {
     if (permission is OrgPermission)
     {
         return base.Contains(permission);
     }
     else if (permission is FilePermissionInfo)
     {
         FilePermissionInfo fp = permission as FilePermissionInfo;
         if (fp.Name.IndexOf(RES_TAG) != -1)
         {
             fp = new FilePermissionInfo(fp.Name.Substring(0, fp.Name.IndexOf(RES_TAG)), fp.Action);
             return base.Contains(fp);
         }
         else if (fp.Name.StartsWith(this.name) )
         {
             return (this.RealAction & fp.RealAction) == fp.RealAction;
         }
     }
     return base.Contains(permission);
 }

 /// <summary>
 /// Gets the Enabled status of the permission
 /// </summary>
 /// <param name="objPerm">The permission being loaded</param>
 /// <param name="role">The role</param>
 /// <param name="column">The column of the Grid</param>
 /// <history>
 ///     [cnurse]    01/13/2006  Created
 /// </history>
 protected virtual bool GetEnabled(PermissionInfo objPerm, RoleInfo role, int column)
 {
     return true;
 }

 protected override bool IsViewPermisison(PermissionInfo permissionInfo)
 {
     return (permissionInfo.PermissionKey == "VIEW");
 }

 protected override bool IsFullControl(PermissionInfo permissionInfo)
 {
     return (permissionInfo.PermissionKey == "EDIT") && PermissionProvider.Instance().SupportsFullControl();
 }

 /// -----------------------------------------------------------------------------
 /// <summary>
 /// Gets the Value of the permission
 /// </summary>
 /// <param name="objPerm">The permission being loaded</param>
 /// <param name="role">The role</param>
 /// <param name="column">The column of the Grid</param>
 /// <param name="defaultState">Default State.</param>
 /// <returns>A Boolean (True or False)</returns>
 /// -----------------------------------------------------------------------------
 protected override string GetPermission(PermissionInfo objPerm, RoleInfo role, int column, string defaultState)
 {
     string permission;
     if (InheritViewPermissionsFromTab && column == _ViewColumnIndex)
     {
         permission = PermissionTypeNull;
     }
     else
     {
         permission = role.RoleID == AdministratorRoleId 
                         ? PermissionTypeGrant 
                         : base.GetPermission(objPerm, role, column, defaultState);
     }
     return permission;
 }

 /// -----------------------------------------------------------------------------
 /// <summary>
 /// Gets the Enabled status of the permission
 /// </summary>
 /// <param name="objPerm">The permission being loaded</param>
 /// <param name="user">The user</param>
 /// <param name="column">The column of the Grid</param>
 /// -----------------------------------------------------------------------------
 protected override bool GetEnabled(PermissionInfo objPerm, UserInfo user, int column)
 {
     bool enabled;
     if (InheritViewPermissionsFromTab && column == _ViewColumnIndex)
     {
         enabled = false;
     }
     else
     {
         enabled = true;
     }
     return enabled;
 }

 /// <summary>
 /// Updates a Permission
 /// </summary>
 /// <param name="permission">The permission being updated</param>
 /// <param name="roleId">Rold Id.</param>
 /// <param name="roleName">The name of the role</param>
 /// <param name="allowAccess">The value of the permission</param>
 /// <history>
 ///     [cnurse]    01/12/2006  Created
 /// </history>
 protected virtual void UpdatePermission(PermissionInfo permission, int roleId, string roleName, bool allowAccess)
 {
     if (allowAccess)
     {
         UpdatePermission(permission, roleId, roleName, PermissionTypeGrant);
     }
     else
     {
         UpdatePermission(permission, roleId, roleName, PermissionTypeNull);
     }
 }

 /// <summary>
 /// Gets the Value of the permission
 /// </summary>
 /// <param name="objPerm">The permission being loaded</param>
 /// <param name="user">The user</param>
 /// <param name="column">The column of the Grid</param>
 /// <param name="defaultState">Default State.</param>
 /// <history>
 ///     [cnurse]    01/13/2006  Created
 /// </history>
 protected virtual string GetPermission(PermissionInfo objPerm, UserInfo user, int column, string defaultState)
 {
     var stateKey = defaultState;
     if (PermissionsList != null)
     {
         foreach (var permission in PermissionsList)
         {
             if (permission.PermissionID == objPerm.PermissionID && permission.UserID == user.UserID)
             {
                 if (permission.AllowAccess)
                 {
                     stateKey = PermissionTypeGrant;
                 }
                 else
                 {
                     stateKey = PermissionTypeDeny;
                 }
                 break;
             }
         }
     }
     return stateKey;
 }

 /// -----------------------------------------------------------------------------
 /// <summary>
 /// Gets the Enabled status of the permission
 /// </summary>
 /// <param name="objPerm">The permission being loaded</param>
 /// <param name="user">The user</param>
 /// <param name="column">The column of the Grid</param>
 /// <history>
 ///     [cnurse]    01/13/2006  Created
 /// </history>
 /// -----------------------------------------------------------------------------
 protected override bool GetEnabled(PermissionInfo objPerm, UserInfo user, int column)
 {
     return InheritViewPermissionsFromTab && column != _ViewColumnIndex;
 }

 /// -----------------------------------------------------------------------------
 /// <summary>
 /// Gets the Value of the permission
 /// </summary>
 /// <param name="objPerm">The permission being loaded</param>
 /// <param name="user">The role</param>
 /// <param name="column">The column of the Grid</param>
 /// <param name="defaultState">Default State.</param>
 /// <returns>A Boolean (True or False)</returns>
 /// <history>
 ///     [cnurse]    01/09/2006  Created
 /// </history>
 /// -----------------------------------------------------------------------------
 protected override string GetPermission(PermissionInfo objPerm, UserInfo user, int column, string defaultState)
 {
     string permission;
     if (InheritViewPermissionsFromTab && column == _ViewColumnIndex)
     {
         permission = PermissionTypeNull;
     }
     else
     {
         //Call base class method to handle standard permissions
         permission = base.GetPermission(objPerm, user, column, defaultState);
     }
     return permission;
 }

        protected override void AddPermission(PermissionInfo permission, int roleId, string roleName, int userId, string displayName, bool allowAccess)
        {
            var objPermission = new ModulePermissionInfo(permission);
            objPermission.ModuleID = ModuleID;
            objPermission.RoleID = roleId;
            objPermission.RoleName = roleName;
            objPermission.AllowAccess = allowAccess;
            objPermission.UserID = userId;
            objPermission.DisplayName = displayName;
            _ModulePermissions.Add(objPermission, true);

            //Clear Permission List
            _PermissionsList = null;
        }

 protected virtual void AddPermission(PermissionInfo permission, int roleId, string roleName, int userId, string displayName, bool allowAccess)
 {
 }