/// <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);
}
/// <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="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="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="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);
}
/// <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);
}
/// <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="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="userInfo">用户</param>
/// <param name="id">主键</param>
/// <returns>实体</returns>
public BasePermissionItemEntity GetEntity(BaseUserInfo userInfo, string id)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity();
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);
DataTable returnDataTable = new DataTable(BasePermissionItemEntity.TableName);
returnDataTable = permissionItemManager.GetDataTableById(id);
permissionItemEntity = new BasePermissionItemEntity(returnDataTable);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.PermissionItemService_GetEntity, 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>
/// <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="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);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/// 测试权限用的
/////////////////////////////////////////////////////////////////////////////////////////////////////////
#region public string AddPermission(BaseUserInfo userInfo, string permissionCode)
/// <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="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="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));
}
//
// ResourcePermission 权限判断
//
#region public bool CheckPermissionByUser(string userId, string permissionItemCode, string permissionItemName = null) 是否有相应的权限
/// <summary>
/// 是否有相应的权限
/// </summary>
/// <param name="userId">用户主键</param>
/// <param name="permissionItemCode">权限编号</param>
/// <param name="permissionItemName">权限名称</param>
/// <returns>是否有权限</returns>
public bool CheckPermissionByUser(string userId, string permissionItemCode, string permissionItemName = null)
{
// 若不存在就需要自动能增加一个操作权限项
string tableName = BasePermissionItemEntity.TableName;
if (!string.IsNullOrEmpty(BaseSystemInfo.SystemCode))
{
tableName = BaseSystemInfo.SystemCode + "PermissionItem";
}
BasePermissionItemManager permissionItemManager = new BasePermissionItemManager(DbHelper, UserInfo, tableName);
string permissionItemId = permissionItemManager.GetIdByAdd(permissionItemCode, permissionItemName);
BasePermissionItemEntity permissionItemEntity = permissionItemManager.GetEntity(permissionItemId);
// 先判断用户类别
if (UserInfo.IsAdministrator)
{
return(true);
}
// 没有找到相应的权限
if (String.IsNullOrEmpty(permissionItemId))
{
return(false);
}
// 这里需要判断,是系统权限？
bool returnValue = false;
BaseUserManager userManager = new BaseUserManager(this.DbHelper, this.UserInfo);
if (!string.IsNullOrEmpty(permissionItemEntity.CategoryCode) && permissionItemEntity.CategoryCode.Equals("System"))
{
// 用户管理员
returnValue = userManager.IsInRoleByCode(userId, "UserAdmin");
if (returnValue)
{
return(returnValue);
}
}
// 这里需要判断,是业务权限？
if (!string.IsNullOrEmpty(permissionItemEntity.CategoryCode) && permissionItemEntity.CategoryCode.Equals("Application"))
{
returnValue = userManager.IsInRoleByCode(userId, "Admin");
if (returnValue)
{
return(returnValue);
}
}
// 判断用户权限
if (this.CheckUserPermission(userId, permissionItemId))
{
return(true);
}
// 判断用户角色权限
if (this.CheckUserRolePermission(userId, permissionItemId))
{
return(true);
}
// 判断用户组织机构权限，这里有开关是为了提高性能用的，
// 下面的函数接着还可以提高性能，可以进行一次判断就可以了，其实不用执行4次判断，浪费I/O，浪费性能。
if (BaseSystemInfo.UseOrganizePermission)
{
if (this.CheckUserOrganizePermission(userId, permissionItemId, this.UserInfo.WorkgroupId))
{
return(true);
}
else if (this.CheckUserOrganizePermission(userId, permissionItemId, this.UserInfo.DepartmentId))
{
return(true);
}
else if (this.CheckUserOrganizePermission(userId, permissionItemId, this.UserInfo.SubCompanyId))
{
return(true);
}
else if (this.CheckUserOrganizePermission(userId, permissionItemId, this.UserInfo.CompanyId))
{
return(true);
}
}
return(false);
}
/// <summary>
/// 更新
/// </summary>
/// <param name="permissionItemEntity">实体</param>
public int Update(BasePermissionItemEntity permissionItemEntity)
{
return(this.UpdateEntity(permissionItemEntity));
}
/// <summary>
/// 添加
/// </summary>
/// <param name="permissionItemEntity">实体</param>
/// <returns>主键</returns>
public string Add(BasePermissionItemEntity permissionItemEntity)
{
return(this.AddEntity(permissionItemEntity));
}
partial void SetEntityExpand(SQLBuilder sqlBuilder, BasePermissionItemEntity 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 == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(BasePermissionItemEntity.FieldId, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
sqlBuilder.SetFormula(BasePermissionItemEntity.FieldId, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
}
}
else
{
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.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 == CurrentDbType.SqlServer && this.Identity)
{
sequence = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
return(sequence);
}
/// <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);
}
