/// <summary>
        /// 添加操作权限项
        /// </summary>
        /// <param name="userInfo">当前用户</param>
        /// <param name="permissionEntity">权限定义实体</param>
        /// <param name="statusCode">状态码</param>
        /// <param name="statusMessage">状态信息</param>
        /// <returns>主键</returns>
        public string Add(BaseUserInfo userInfo, BasePermissionItemEntity permissionItemEntity, out string statusCode, out string statusMessage)
        {
            // 写入调试信息
            #if (DEBUG)
                int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
            #endif

            // 加强安全验证防止未授权匿名调用
            #if (!DEBUG)
                LogOnService.UserIsLogOn(userInfo);
            #endif

            statusCode = string.Empty;
            statusMessage = string.Empty;
            string returnValue = string.Empty;
            using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
            {
                try
                {
                    dbHelper.Open(UserCenterDbConnection);
                    // 数据库事务开始
                    // dbHelper.BeginTransaction();
                    string tableName = BasePermissionItemEntity.TableName;
                    if (!string.IsNullOrEmpty(BaseSystemInfo.SystemCode))
                    {
                        tableName = BaseSystemInfo.SystemCode + "PermissionItem";
                    }
                    BasePermissionItemManager permissionItemManager = new BasePermissionItemManager(dbHelper, userInfo, tableName);
                    returnValue = permissionItemManager.Add(permissionItemEntity, out statusCode);
                    // 获得状态消息
                    statusMessage = permissionItemManager.GetStateMessage(statusCode);
                    // 写入日志信息
                    BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.PermissionItemService_Add, MethodBase.GetCurrentMethod());
                    // 数据库事务提交
                    // dbHelper.CommitTransaction();
                }
                catch (Exception ex)
                {
                    // 数据库事务回滚
                    // dbHelper.RollbackTransaction();
                    // 记录异常信息
                    BaseExceptionManager.LogException(dbHelper, userInfo, ex);
                    throw ex;
                }
                finally
                {
                    dbHelper.Close();
                }
            }

            // 写入调试信息
            #if (DEBUG)
                BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
            #endif

            return returnValue;
        }
        /// <summary>
        /// 用户角色关系是否有模块权限
        /// </summary>
        /// <param name="roleId">角色主键</param>
        /// <param name="permissionItemCode">权限编号</param>
        /// <returns>有角色权限</returns>
        public bool CheckPermissionByRole(string roleId, string permissionItemCode)
        {
            BasePermissionItemManager permissionItemManager = new BasePermissionItemManager(DbHelper, UserInfo);
            string permissionItemId = permissionItemManager.GetProperty(new KeyValuePair<string, object>(BasePermissionItemEntity.FieldCode, permissionItemCode), BasePermissionItemEntity.FieldId);
            // 判断当前判断的权限是否存在,否则很容易出现前台设置了权限,后台没此项权限
            // 需要自动的能把前台判断过的权限,都记录到后台来
            #if (DEBUG)
                if (String.IsNullOrEmpty(permissionItemId))
                {
                    BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity();
                    permissionItemEntity.Code = permissionItemCode;
                    permissionItemEntity.FullName = permissionItemCode;
                    permissionItemEntity.ParentId = string.Empty;
                    permissionItemEntity.IsScope = 0;
                    permissionItemEntity.AllowDelete = 1;
                    permissionItemEntity.AllowEdit = 1;
                    permissionItemEntity.DeletionStateCode = 0;
                    permissionItemEntity.Enabled = 1;
                    // 这里是防止主键重复?
                    // permissionEntity.ID = BaseBusinessLogic.NewGuid();
                    permissionItemManager.AddEntity(permissionItemEntity);
                }
                else
                {
                    // 更新最后一次访问日期,设置为当前服务器日期
                    SQLBuilder sqlBuilder = new SQLBuilder(DbHelper);
                    sqlBuilder.BeginUpdate(this.CurrentTableName);
                    sqlBuilder.SetDBNow(BasePermissionItemEntity.FieldLastCall);
                    sqlBuilder.SetWhere(BasePermissionItemEntity.FieldId, permissionItemId);
                    sqlBuilder.EndUpdate();
                }
            #endif

            if (string.IsNullOrEmpty(permissionItemId))
            {
                return false;
            }
            string sqlQuery = " SELECT COUNT(*) "
                            + "   FROM " + this.CurrentTableName
                            + "  WHERE " + "(" + BasePermissionEntity.FieldResourceCategory + " = '" + BaseRoleEntity.TableName + "') "
                            + "        AND (" + BasePermissionEntity.FieldEnabled + " = 1) "
                            + "        AND (" + BasePermissionEntity.FieldResourceId + " = '" + roleId + "' ) "
                            + "        AND (" + BasePermissionEntity.FieldPermissionItemId + " = '" + permissionItemId + "') ";
            int rowCount = 0;
            object returnObject = DbHelper.ExecuteScalar(sqlQuery);
            if (returnObject != null)
            {
                rowCount = int.Parse(returnObject.ToString());
            }
            return rowCount > 0;
        }
 /// <summary>
 /// 添加
 /// </summary>
 /// <param name="permissionEntity">实体</param>
 /// <param name="statusCode">返回状态码</param>
 /// <returns>主键</returns>
 public string Add(BasePermissionItemEntity permissionItemEntity, out string statusCode)
 {
     string returnValue = string.Empty;
     // 检查编号是否重复
     if (this.Exists(new KeyValuePair<string, object>(BasePermissionItemEntity.FieldDeletionStateCode, 0), new KeyValuePair<string, object>(BasePermissionItemEntity.FieldCode, permissionItemEntity.Code)))
     {
         // 编号已重复
         statusCode = StatusCode.ErrorCodeExist.ToString();
     }
     else
     {
         returnValue = this.AddEntity(permissionItemEntity);
         // 运行成功
         statusCode = StatusCode.OKAdd.ToString();
     }
     return returnValue;
 }
        /// <summary>
        /// 添加操作权限
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="permissionCode">权限编号</param>
        /// <returns>主键</returns>
        public string AddPermission(BaseUserInfo userInfo, string permissionCode)
        {
            // 加强安全验证防止未授权匿名调用
            #if (!DEBUG)
                LogOnService.UserIsLogOn(userInfo);
            #endif

            string returnValue = string.Empty;
            using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
            {
                try
                {
                    dbHelper.Open(UserCenterDbConnection);
                    BasePermissionItemManager permissionItemManager = new BasePermissionItemManager(dbHelper, userInfo);
                    string statusCode = string.Empty;
                    BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity();
                    permissionItemEntity.Code = permissionCode;
                    permissionItemEntity.Enabled = 1;
                    permissionItemEntity.AllowDelete = 1;
                    permissionItemEntity.AllowEdit = 1;
                    permissionItemEntity.IsScope = 0;
                    returnValue = permissionItemManager.Add(permissionItemEntity, out statusCode);
                    BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.MSG0091, MethodBase.GetCurrentMethod());
                }
                catch (Exception ex)
                {
                    BaseExceptionManager.LogException(dbHelper, userInfo, ex);
                    throw ex;
                }
                finally
                {
                    dbHelper.Close();
                }
            }

            return returnValue;
        }
 /// <summary>
 /// 获取实体
 /// </summary>
 /// <param name="id">主键</param>
 public BasePermissionItemEntity GetEntity(string id)
 {
     BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity(this.GetDataTable(new KeyValuePair<string, object>(BasePermissionItemEntity.FieldId, id)));
     return permissionItemEntity;
 }
 /// <summary>
 /// 添加实体
 /// </summary>
 /// <param name="permissionItemEntity">实体</param>
 public string AddEntity(BasePermissionItemEntity permissionItemEntity)
 {
     string sequence = string.Empty;
     if (permissionItemEntity.SortCode == 0)
     {
         BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
         sequence = sequenceManager.GetSequence(this.CurrentTableName);
         permissionItemEntity.SortCode = int.Parse(sequence);
     }
     SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
     sqlBuilder.BeginInsert(this.CurrentTableName, BasePermissionItemEntity.FieldId);
     if (!this.Identity)
     {
         sqlBuilder.SetValue(BasePermissionItemEntity.FieldId, permissionItemEntity.Id);
     }
     else
     {
         if (!this.ReturnId && (DbHelper.CurrentDbType == DbTypes.Oracle || DbHelper.CurrentDbType == DbTypes.DB2))
         {
             if (DbHelper.CurrentDbType == DbTypes.Oracle)
             {
                 sqlBuilder.SetFormula(BasePermissionItemEntity.FieldId, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
             }
             if (DbHelper.CurrentDbType == DbTypes.DB2)
             {
                 sqlBuilder.SetFormula(BasePermissionItemEntity.FieldId, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
             }
         }
         else
         {
             if (this.Identity && (DbHelper.CurrentDbType == DbTypes.Oracle || DbHelper.CurrentDbType == DbTypes.DB2))
             {
                 if (permissionItemEntity.Id == null)
                 {
                     if (string.IsNullOrEmpty(sequence))
                     {
                         BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
                         sequence = sequenceManager.GetSequence(this.CurrentTableName);
                     }
                     permissionItemEntity.Id = int.Parse(sequence);
                 }
                 sqlBuilder.SetValue(BasePermissionItemEntity.FieldId, permissionItemEntity.Id);
             }
         }
     }
     this.SetEntity(sqlBuilder, permissionItemEntity);
     if (UserInfo != null)
     {
         sqlBuilder.SetValue(BasePermissionItemEntity.FieldCreateUserId, UserInfo.Id);
         sqlBuilder.SetValue(BasePermissionItemEntity.FieldCreateBy, UserInfo.RealName);
     }
     sqlBuilder.SetDBNow(BasePermissionItemEntity.FieldCreateOn);
     if (UserInfo != null)
     {
         sqlBuilder.SetValue(BasePermissionItemEntity.FieldModifiedUserId, UserInfo.Id);
         sqlBuilder.SetValue(BasePermissionItemEntity.FieldModifiedBy, UserInfo.RealName);
     }
     sqlBuilder.SetDBNow(BasePermissionItemEntity.FieldModifiedOn);
     if (DbHelper.CurrentDbType == DbTypes.SqlServer && this.Identity)
     {
         sequence = sqlBuilder.EndInsert().ToString();
     }
     else
     {
         sqlBuilder.EndInsert();
     }
     return sequence;
 }
 /// <summary>
 /// 添加
 /// </summary>
 /// <param name="permissionItemEntity">实体</param>
 /// <param name="identity">自增量方式</param>
 /// <param name="returnId">返回主鍵</param>
 /// <returns>主键</returns>
 public string Add(BasePermissionItemEntity permissionItemEntity, bool identity, bool returnId)
 {
     this.Identity = identity;
     this.ReturnId = returnId;
     return this.AddEntity(permissionItemEntity);
 }
 /// <summary>
 /// 添加
 /// </summary>
 /// <param name="permissionItemEntity">实体</param>
 /// <returns>主键</returns>
 public string Add(BasePermissionItemEntity permissionItemEntity)
 {
     return this.AddEntity(permissionItemEntity);
 }
        /// <summary>
        /// 检查删除选择项的有效性
        /// </summary>
        /// <returns>有效</returns>
        private bool CheckInputBatchDelete()
        {
            bool returnValue = true;
            int selectedCount = 0;

            foreach (DataGridViewRow dgvRow in grdPermission.Rows)
            {
                DataRow dataRow = (dgvRow.DataBoundItem as DataRowView).Row;
                if ((System.Boolean)(dgvRow.Cells["colSelected"].Value??false))
                {
                    // break;
                    // 是否有子节点
                    string id = dataRow[BasePermissionItemEntity.FieldId].ToString();
                    BaseInterfaceLogic.FindTreeNode(this.tvPermission, id);
                    if (BaseInterfaceLogic.TargetNode != null)
                    {
                        if (!BaseInterfaceLogic.NodeAllowDelete(BaseInterfaceLogic.TargetNode))
                        {
                            MessageBox.Show(AppMessage.Format(AppMessage.MSG0035, BaseInterfaceLogic.TargetNode.Text), AppMessage.MSG0000, MessageBoxButtons.OK, MessageBoxIcon.Information);
                            returnValue = false;
                            return returnValue;
                        }
                    }

                    BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity(dataRow);
                    if (permissionItemEntity.AllowDelete.ToString().Equals("0"))
                    {
                        // 有不允许删除的数据
                        MessageBox.Show(AppMessage.Format(AppMessage.MSG0018, permissionItemEntity.FullName), AppMessage.MSG0000, MessageBoxButtons.OK, MessageBoxIcon.Information);
                        returnValue = false;
                        break;
                    }
                }
                if ((System.Boolean)(dgvRow.Cells["colSelected"].Value??false))
                {
                    // 有记录被选中了
                    returnValue = true;
                    // break;
                    // 是否有子节点
                    string id = dataRow[BasePermissionItemEntity.FieldId].ToString();
                    BaseInterfaceLogic.FindTreeNode(this.tvPermission, id);
                    if (BaseInterfaceLogic.TargetNode != null)
                    {
                        if (!BaseInterfaceLogic.NodeAllowDelete(BaseInterfaceLogic.TargetNode))
                        {
                            MessageBox.Show(AppMessage.Format(AppMessage.MSG0035, BaseInterfaceLogic.TargetNode.Text), AppMessage.MSG0000, MessageBoxButtons.OK, MessageBoxIcon.Information);
                            returnValue = false;
                            return returnValue;
                        }
                    }

                    BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity(dataRow);
                    if (permissionItemEntity.AllowDelete.ToString().Equals("0"))
                    {
                        // 有不允许删除的数据
                        MessageBox.Show(AppMessage.Format(AppMessage.MSG0018, permissionItemEntity.FullName), AppMessage.MSG0000, MessageBoxButtons.OK, MessageBoxIcon.Information);
                        returnValue = false;
                        break;
                    }

                    selectedCount++;
                }
            }

            //foreach (DataRow dataRow in this.DTPermissionList.Rows)
            //{
            //    if (dataRow["colSelected"].ToString() == true.ToString())
            //    {
            //        // break;
            //        // 是否有子节点
            //        string id = dataRow[BasePermissionItemEntity.FieldId].ToString();
            //        BaseInterfaceLogic.FindTreeNode(this.tvPermission, id);
            //        if (BaseInterfaceLogic.TargetNode != null)
            //        {
            //            if (!BaseInterfaceLogic.NodeAllowDelete(BaseInterfaceLogic.TargetNode))
            //            {
            //                MessageBox.Show(AppMessage.Format(AppMessage.MSG0035, BaseInterfaceLogic.TargetNode.Text), AppMessage.MSG0000, MessageBoxButtons.OK, MessageBoxIcon.Information);
            //                returnValue = false;
            //                return returnValue;
            //            }
            //        }

            //        BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity(dataRow);
            //        if (permissionItemEntity.AllowDelete.ToString().Equals("0"))
            //        {
            //            // 有不允许删除的数据
            //            MessageBox.Show(AppMessage.Format(AppMessage.MSG0018, permissionItemEntity.FullName), AppMessage.MSG0000, MessageBoxButtons.OK, MessageBoxIcon.Information);
            //            returnValue = false;
            //            break;
            //        }
            //    }
            //    if (dataRow["colSelected"].ToString() == true.ToString())
            //    {
            //        // 有记录被选中了
            //        returnValue = true;
            //        // break;
            //        // 是否有子节点
            //        string id = dataRow[BasePermissionItemEntity.FieldId].ToString();
            //        BaseInterfaceLogic.FindTreeNode(this.tvPermission, id);
            //        if (BaseInterfaceLogic.TargetNode != null)
            //        {
            //            if (!BaseInterfaceLogic.NodeAllowDelete(BaseInterfaceLogic.TargetNode))
            //            {
            //                MessageBox.Show(AppMessage.Format(AppMessage.MSG0035, BaseInterfaceLogic.TargetNode.Text), AppMessage.MSG0000, MessageBoxButtons.OK, MessageBoxIcon.Information);
            //                returnValue = false;
            //                return returnValue;
            //            }
            //        }

            //        BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity(dataRow);
            //        if (permissionItemEntity.AllowDelete.ToString().Equals("0"))
            //        {
            //            // 有不允许删除的数据
            //            MessageBox.Show(AppMessage.Format(AppMessage.MSG0018, permissionItemEntity.FullName), AppMessage.MSG0000, MessageBoxButtons.OK, MessageBoxIcon.Information);
            //            returnValue = false;
            //            break;
            //        }

            //        selectedCount++;
            //    }
            //}
            if (returnValue && selectedCount == 0)
            {
                returnValue = false;
                MessageBox.Show(AppMessage.MSGC023, AppMessage.MSG0000, MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            return returnValue;
        }
        public override void FormOnLoad()
        {
            // 表格显示序号的处理部分
            this.DataGridViewOnLoad(grdRole);
            // 获取分类列表
            this.BindItemDetails();
            if (string.IsNullOrEmpty(this.TargetPermissionId))
            {
                DataTable dtPermissionItem = this.GetPermissionItemScop(this.PermissionItemScopeCode);
                dtPermissionItem.DefaultView.Sort = BasePermissionItemEntity.FieldSortCode;
                // 只显示权限域的权限列表
                BaseBusinessLogic.SetFilter(dtPermissionItem, BasePermissionItemEntity.FieldIsScope, "1");
                if (dtPermissionItem.Rows.Count > 0)
                {
                    BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity(dtPermissionItem.Rows[0]);
                    this.ucPermissionScope.SelectedId = permissionItemEntity.Id.ToString();
                }
            }
            this.grdRole.AutoGenerateColumns = false;

            this.GetRoleOrganizeScope();

            this.SetControlState();
        }
 /// <summary>
 /// 设置实体
 /// </summary>
 /// <param name="permissionItemEntity">实体</param>
 private void SetEntity(SQLBuilder sqlBuilder, BasePermissionItemEntity permissionItemEntity)
 {
     sqlBuilder.SetValue(BasePermissionItemEntity.FieldParentId, permissionItemEntity.ParentId);
     sqlBuilder.SetValue(BasePermissionItemEntity.FieldCode, permissionItemEntity.Code);
     sqlBuilder.SetValue(BasePermissionItemEntity.FieldFullName, permissionItemEntity.FullName);
     sqlBuilder.SetValue(BasePermissionItemEntity.FieldCategoryCode, permissionItemEntity.CategoryCode);
     sqlBuilder.SetValue(BasePermissionItemEntity.FieldIsScope, permissionItemEntity.IsScope);
     sqlBuilder.SetValue(BasePermissionItemEntity.FieldIsPublic, permissionItemEntity.IsPublic);
     sqlBuilder.SetValue(BasePermissionItemEntity.FieldAllowEdit, permissionItemEntity.AllowEdit);
     sqlBuilder.SetValue(BasePermissionItemEntity.FieldAllowDelete, permissionItemEntity.AllowDelete);
     sqlBuilder.SetValue(BasePermissionItemEntity.FieldLastCall, permissionItemEntity.LastCall);
     sqlBuilder.SetValue(BasePermissionItemEntity.FieldEnabled, permissionItemEntity.Enabled);
     sqlBuilder.SetValue(BasePermissionItemEntity.FieldDeletionStateCode, permissionItemEntity.DeletionStateCode);
     sqlBuilder.SetValue(BasePermissionItemEntity.FieldSortCode, permissionItemEntity.SortCode);
     sqlBuilder.SetValue(BasePermissionItemEntity.FieldDescription, permissionItemEntity.Description);
     SetEntityExpand(sqlBuilder, permissionItemEntity);
 }
        /// <summary>
        /// 获取一个操作权限的主键
        /// 若不存在就自动增加一个
        /// </summary>
        /// <param name="permissionItemCode">操作权限编号</param>
        /// <param name="permissionItemName">操作权限名称</param>
        /// <returns>主键</returns>
        public string GetIdByAdd(string permissionItemCode, string permissionItemName = null)
        {
            // 判断当前判断的权限是否存在,否则很容易出现前台设置了权限,后台没此项权限
            // 需要自动的能把前台判断过的权限,都记录到后台来

            List<KeyValuePair<string, object>> parameters = new List<KeyValuePair<string, object>>();
            parameters.Add(new KeyValuePair<string, object>(BasePermissionItemEntity.FieldCode, permissionItemCode));
            parameters.Add(new KeyValuePair<string, object>(BasePermissionItemEntity.FieldEnabled, 1));
            parameters.Add(new KeyValuePair<string, object>(BasePermissionItemEntity.FieldDeletionStateCode, 0));

            BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity();
            permissionItemEntity = new BasePermissionItemEntity(this.GetDataTable(parameters, BasePermissionItemEntity.FieldId));

            string permissionItemId = string.Empty;
            if (permissionItemEntity != null)
            {
                permissionItemId = permissionItemEntity.Id.ToString();
            }

            // 若是在调试阶段、有没在的权限被判断了,那就自动加入这个权限,不用人工加入权限了,工作效率会提高很多,
            // 哪些权限是否有被调用什么的,还可以进行一些诊断
            #if (DEBUG)
                if (String.IsNullOrEmpty(permissionItemId))
                {
                    // 这里需要进行一次加锁,方式并发冲突发生
                    lock (PermissionItemLock)
                    {
                        permissionItemEntity.Code = permissionItemCode;
                        if (string.IsNullOrEmpty(permissionItemName))
                        {
                            permissionItemEntity.FullName = permissionItemCode;
                        }
                        else
                        {
                            permissionItemEntity.FullName = permissionItemName;
                        }
                        permissionItemEntity.ParentId = null;
                        permissionItemEntity.IsScope = 0;
                        permissionItemEntity.AllowDelete = 1;
                        permissionItemEntity.AllowEdit = 1;
                        permissionItemEntity.Enabled = 1;
                        // 这里是防止主键重复?
                        // permissionEntity.ID = BaseBusinessLogic.NewGuid();
                        permissionItemId = this.AddEntity(permissionItemEntity);
                    }
                }
                else
                {
                    // 更新最后一次访问日期,设置为当前服务器日期
                    SQLBuilder sqlBuilder = new SQLBuilder(DbHelper);
                    sqlBuilder.BeginUpdate(this.CurrentTableName);
                    sqlBuilder.SetDBNow(BasePermissionItemEntity.FieldLastCall);
                    sqlBuilder.SetWhere(BasePermissionItemEntity.FieldId, permissionItemId);
                    sqlBuilder.EndUpdate();
                }
                #endif

            return permissionItemId;
        }
 /// <summary>
 /// 获取一个
 /// </summary>
 /// <param name="code">编号</param>
 /// <param name="permissionEntity">实体</param>
 /// <returns>数据表</returns>
 public DataTable GetByCode(string code, BasePermissionItemEntity permissionItemEntity)
 {
     DataTable dataTable = this.GetDataTable(new KeyValuePair<string, object>(BasePermissionItemEntity.FieldCode, code));
     permissionItemEntity.GetSingle(dataTable);
     return dataTable;
 }
 /// <summary>
 /// 批量保存
 /// </summary>
 /// <param name="dataTable">数据表</param>
 /// <returns>影响行数</returns>
 public override int BatchSave(DataTable dataTable)
 {
     int returnValue = 0;
     BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity();
     foreach (DataRow dataRow in dataTable.Rows)
     {
         // 删除状态
         if (dataRow.RowState == DataRowState.Deleted)
         {
             string id = dataRow[BasePermissionItemEntity.FieldId, DataRowVersion.Original].ToString();
             if (id.Length > 0)
             {
                 if (dataRow[BasePermissionItemEntity.FieldAllowDelete, DataRowVersion.Original].ToString().Equals("1"))
                 {
                     returnValue += this.DeleteEntity(id);
                 }
             }
         }
         // 被修改过
         if (dataRow.RowState == DataRowState.Modified)
         {
             string id = dataRow[BasePermissionItemEntity.FieldId, DataRowVersion.Original].ToString();
             if (id.Length > 0)
             {
                 permissionItemEntity.GetFrom(dataRow);
                 // 判断是否允许编辑
                 if (permissionItemEntity.AllowEdit == 1)
                 {
                     returnValue += this.UpdateEntity(permissionItemEntity);
                 }
                 else
                 {
                     // 不允许编辑,但是排序还是允许的
                     returnValue += this.SetProperty(new KeyValuePair<string, object>(BasePermissionItemEntity.FieldId, id), new KeyValuePair<string, object>(BasePermissionItemEntity.FieldSortCode, permissionItemEntity.SortCode));
                 }
             }
         }
         // 添加状态
         if (dataRow.RowState == DataRowState.Added)
         {
             permissionItemEntity.GetFrom(dataRow);
             returnValue += this.AddEntity(permissionItemEntity).Length > 0 ? 1 : 0;
         }
         if (dataRow.RowState == DataRowState.Unchanged)
         {
             continue;
         }
         if (dataRow.RowState == DataRowState.Detached)
         {
             continue;
         }
     }
     return returnValue;
 }
 public FrmPermissionItemAdd(BasePermissionItemEntity entity)
     : this()
 {
     this.permissionItemEntity = entity;
 }
        /// <summary>
        /// 按编号获取实体
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="code">编号</param>
        /// <returns>实体</returns>
        public BasePermissionItemEntity GetEntityByCode(BaseUserInfo userInfo, string code)
        {
            // 写入调试信息
            #if (DEBUG)
                int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
            #endif

            // 加强安全验证防止未授权匿名调用
            #if (!DEBUG)
                LogOnService.UserIsLogOn(userInfo);
            #endif

            BasePermissionItemEntity permissionItemEntity = null;
            using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
            {
                try
                {
                    dbHelper.Open(UserCenterDbConnection);
                    string tableName = BasePermissionItemEntity.TableName;
                    if (!string.IsNullOrEmpty(BaseSystemInfo.SystemCode))
                    {
                        tableName = BaseSystemInfo.SystemCode + "PermissionItem";
                    }
                    BasePermissionItemManager permissionItemManager = new BasePermissionItemManager(dbHelper, userInfo, tableName);
                    permissionItemEntity = new BasePermissionItemEntity(permissionItemManager.GetDataTableByCode(code));
                    BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.PermissionItemService_GetEntityByCode, MethodBase.GetCurrentMethod());
                }
                catch (Exception ex)
                {
                    BaseExceptionManager.LogException(dbHelper, userInfo, ex);
                    throw ex;
                }
                finally
                {
                    dbHelper.Close();
                }
            }

            // 写入调试信息
            #if (DEBUG)
                BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
            #endif

            return permissionItemEntity;
        }
 /// <summary>
 /// 加载窗体
 /// </summary>
 public override void FormOnLoad()
 {
     // 调用接口方式实现
     // this.PermissionEntity = Singleton<PermissionAdminService>.Instance.Get(UserInfo, this.PermissionEntity.Id);
     this.PermissionItemEntity = DotNetService.Instance.PermissionItemService.GetEntity(UserInfo, this.PermissionItemEntity.Id.ToString());
     // 获得页面的权限
     this.GetPermission();
     // 显示内容
     this.ShowEntity();
 }
 /// <summary>
 /// 更新
 /// </summary>
 /// <param name="permissionItemEntity">实体</param>
 public int Update(BasePermissionItemEntity permissionItemEntity)
 {
     return this.UpdateEntity(permissionItemEntity);
 }
 /// <summary>
 /// 更新实体
 /// </summary>
 /// <param name="permissionItemEntity">实体</param>
 public int UpdateEntity(BasePermissionItemEntity permissionItemEntity)
 {
     SQLBuilder sqlBuilder = new SQLBuilder(DbHelper);
     sqlBuilder.BeginUpdate(this.CurrentTableName);
     this.SetEntity(sqlBuilder, permissionItemEntity);
     if (UserInfo != null)
     {
         sqlBuilder.SetValue(BasePermissionItemEntity.FieldModifiedUserId, UserInfo.Id);
         sqlBuilder.SetValue(BasePermissionItemEntity.FieldModifiedBy, UserInfo.RealName);
     }
     sqlBuilder.SetDBNow(BasePermissionItemEntity.FieldModifiedOn);
     sqlBuilder.SetWhere(BasePermissionItemEntity.FieldId, permissionItemEntity.Id);
     return sqlBuilder.EndUpdate();
 }
 /// <summary>
 /// 更新一个
 /// </summary>
 /// <param name="permissionEntity">实体</param>
 /// <param name="statusCode">返回状态码</param>
 /// <returns>影响行数</returns>
 public int Update(BasePermissionItemEntity permissionItemEntity, out string statusCode)
 {
     int returnValue = 0;
     // 检查是否已被其他人修改
     //if (DbLogic.IsModifed(DbHelper, BasePermissionEntity.TableName, permissionEntity.Id, permissionEntity.ModifiedUserId, permissionEntity.ModifiedOn))
     //{
     //    // 数据已经被修改
     //    statusCode = StatusCode.ErrorChanged.ToString();
     //}
     //else
     //{
         // 检查编号是否重复
     if (this.Exists(new KeyValuePair<string, object>(BasePermissionItemEntity.FieldDeletionStateCode, 0), new KeyValuePair<string, object>(BasePermissionItemEntity.FieldCode, permissionItemEntity.Code), permissionItemEntity.Id))
         {
             // 文件夹名已重复
             statusCode = StatusCode.ErrorCodeExist.ToString();
         }
         else
         {
             // 进行更新操作
             returnValue = this.UpdateEntity(permissionItemEntity);
             if (returnValue == 1)
             {
                 statusCode = StatusCode.OKUpdate.ToString();
             }
             else
             {
                 // 数据可能被删除
                 statusCode = StatusCode.ErrorDeleted.ToString();
             }
         }
     //}
     return returnValue;
 }
partial         void SetEntityExpand(SQLBuilder sqlBuilder, BasePermissionItemEntity permissionItemEntity);
 /// <summary>
 /// 获得已被选择的权限主键数组
 /// <param name="dataRow">数据行</param>
 /// </summary>
 private void GetSelectedId(DataRow dataRow)
 {
     // 获得当前选中的行
     BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity();
     permissionItemEntity.GetFrom(dataRow);
     // 获得具体选中的内容
     if (permissionItemEntity.Id > 0)
     {
         this.SelectedId = permissionItemEntity.Id.ToString();
         this.SelectedFullName = permissionItemEntity.FullName;
     }
 }
Example #23
0
 /// <summary>
 /// 加载权限构树的主键
 /// </summary>
 /// <param name="TreeNode">当前节点</param>
 private void LoadTree(TreeNode treeNode)
 {
     DataRow[] dataRows = null;
     if (treeNode.Tag == null)
     {
         dataRows = this.DTPermission.Select(BasePermissionItemEntity.FieldParentId + " IS NULL OR " + BasePermissionItemEntity.FieldParentId + " = 0", BasePermissionItemEntity.FieldSortCode);
     }
     else
     {
         dataRows = this.DTPermission.Select(BasePermissionItemEntity.FieldParentId + "=" + ((BasePermissionItemEntity)treeNode.Tag).Id.ToString(), BasePermissionItemEntity.FieldSortCode);
     }
     foreach (DataRow dataRow in dataRows)
     {
         BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity(dataRow);
         // 判断不为空的当前节点的子节点
         if ((treeNode.Tag != null) && ((treeNode.Tag as DataRow)[BaseModuleEntity.FieldId].ToString().Length > 0) && (((BasePermissionItemEntity)treeNode.Tag).Id.ToString() != permissionItemEntity.ParentId))
         {
             continue;
         }
         // 当前节点的子节点, 加载根节点
         if ((treeNode.Tag == null) || ((BasePermissionItemEntity)treeNode.Tag).Id.Equals(permissionItemEntity.ParentId))
         {
             TreeNode newTreeNode = new TreeNode();
             newTreeNode.Text = permissionItemEntity.FullName;
             newTreeNode.Tag = permissionItemEntity;
             // 是否已经有这个权限
             newTreeNode.Checked = Array.IndexOf(this.permissionItemIds, permissionItemEntity.Id.ToString()) >= 0;
             if ((treeNode.Tag == null) || ((treeNode.Tag as DataRow)[BaseModuleEntity.FieldId].ToString().Length == 0))
             {
                 // 树的根节点加载
                 this.tvUserPermission.Nodes.Add(newTreeNode);
             }
             else
             {
                 // 节点的子节点加载
                 treeNode.Nodes.Add(newTreeNode);
             }
             // 递归调用本函数
             this.LoadTree(newTreeNode);
         }
     }
 }
 /// <summary>
 /// 读取屏幕中输入的数据
 /// </summary>
 /// <returns>操作权限项实体</returns>
 private BasePermissionItemEntity GetEntity()
 {
     if (this.permissionItemEntity == null)
     {
         this.permissionItemEntity = new BasePermissionItemEntity();
     }
     if (string.IsNullOrEmpty(this.ucParent.SelectedId))
     {
         this.permissionItemEntity.ParentId = null;
     }
     else
     {
         this.permissionItemEntity.ParentId = this.ucParent.SelectedId;
     }
     this.permissionItemEntity.Code = this.txtCode.Text;
     this.permissionItemEntity.FullName = this.txtFullName.Text;
     this.permissionItemEntity.IsScope = this.chkIsScope.Checked ? 1 : 0;
     this.permissionItemEntity.Enabled = this.chkEnabled.Checked ? 1 : 0;
     // this.permissionItemEntity.IsVisible = 1;
     this.permissionItemEntity.DeletionStateCode = 0;
     this.permissionItemEntity.Description = this.txtDescription.Text;
     return this.permissionItemEntity;
 }
 /// <summary>
 /// 添加
 /// </summary>
 /// <param name="code">编号</param>
 /// <param name="fullName">名称</param>
 /// <param name="statusCode">返回状态码</param>
 /// <returns>主键</returns>
 public string AddByDetail(string code, string fullName, out string statusCode)
 {
     BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity();
     permissionItemEntity.Code = code;
     permissionItemEntity.FullName = fullName;
     return this.Add(permissionItemEntity, out statusCode);
 }
        /// <summary>
        /// 用户的所有可授权范围(有授权权限的权限列表)
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="userId">用户主键</param>
        /// <param name="permissionItemCode">权限域编号</param>
        /// <returns>数据表</returns>
        public DataTable GetPermissionItemDTByPermissionScope(BaseUserInfo userInfo, string userId, string permissionItemCode)
        {
            // 写入调试信息
            #if (DEBUG)
                int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
            #endif

            // 加强安全验证防止未授权匿名调用
            #if (!DEBUG)
                LogOnService.UserIsLogOn(userInfo);
            #endif

            DataTable dataTable = new DataTable(BasePermissionItemEntity.TableName);
            using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
            {
                try
                {
                    dbHelper.Open(UserCenterDbConnection);
                    BasePermissionItemManager permissionItemManager = new BasePermissionItemManager(dbHelper, userInfo);
                    string permissionItemId = permissionItemManager.GetId(new KeyValuePair<string, object>(BasePermissionItemEntity.FieldCode, permissionItemCode));
                    // 数据库里没有设置可授权的权限项,系统自动增加一个权限配置项
                    if (String.IsNullOrEmpty(permissionItemId) && permissionItemCode.Equals("Resource.ManagePermission"))
                    {
                        BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity();
                        permissionItemEntity.Code = "Resource.ManagePermission";
                        permissionItemEntity.FullName = "资源管理范围权限(系统默认)";
                        permissionItemEntity.IsScope = 1;
                        permissionItemEntity.Enabled = 1;
                        permissionItemEntity.AllowDelete = 0;
                        permissionItemEntity.AllowDelete = 0;
                        permissionItemManager.AddEntity(permissionItemEntity);
                    }
                    dataTable = permissionItemManager.GetDataTableByUser(userId, permissionItemCode);
                    dataTable.TableName = BasePermissionItemEntity.TableName;
                    BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.PermissionService_GetPermissionItemDTByPermission, MethodBase.GetCurrentMethod());
                }
                catch (Exception ex)
                {
                    BaseExceptionManager.LogException(dbHelper, userInfo, ex);
                    throw ex;
                }
                finally
                {
                    dbHelper.Close();
                }
            }

            // 写入调试信息
            #if (DEBUG)
                BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
            #endif

            return dataTable;
        }