/// <summary>
/// 保存实体修改记录
/// </summary>
/// <param name="entityNew">修改后的实体对象</param>
/// <param name="entityOld">修改前的实体对象</param>
/// <param name="tableName">表名称</param>
public void SaveEntityChangeLog(BaseRoleEntity entityNew, BaseRoleEntity entityOld, string tableName = null)
{
if (string.IsNullOrEmpty(tableName))
{
//统一放在一个公共表 Troy.Cui 2016-08-17
tableName = BaseChangeLogEntity.CurrentTableName;
}
var manager = new BaseChangeLogManager(UserInfo, tableName);
foreach (var property in typeof(BaseRoleEntity).GetProperties())
{
var oldValue = Convert.ToString(property.GetValue(entityOld, null));
var newValue = Convert.ToString(property.GetValue(entityNew, null));
var fieldDescription = property.GetCustomAttributes(typeof(FieldDescription), false).FirstOrDefault() as FieldDescription;
//不记录创建人、修改人、没有修改的记录
if (!fieldDescription.NeedLog || oldValue == newValue)
{
continue;
}
var entity = new BaseChangeLogEntity
{
TableName = CurrentTableName,
TableDescription = FieldExtensions.ToDescription(typeof(BaseRoleEntity), "CurrentTableName"),
ColumnName = property.Name,
ColumnDescription = fieldDescription.Text,
NewValue = newValue,
OldValue = oldValue,
RecordKey = entityOld.Id.ToString()
};
manager.Add(entity, true, false);
}
}
/// <summary>
/// 从缓存获取获取实体
/// </summary>
/// <param name="systemCode">系统编号</param>
/// <param name="name">名称</param>
/// <returns>权限实体</returns>
public static BaseRoleEntity GetEntityByCacheByName(string systemCode, string name)
{
BaseRoleEntity result = null;
if (string.IsNullOrWhiteSpace(systemCode))
{
systemCode = "Base";
}
// 动态读取表中的数据
var tableName = systemCode + "Role";
//2017.12.20增加默认的HttpRuntime.Cache缓存
var cacheKey = "List." + systemCode + ".Role";
//var cacheTime = default(TimeSpan);
var cacheTime = TimeSpan.FromMilliseconds(86400000);
var listRole = CacheUtil.Cache <List <BaseRoleEntity> >(cacheKey, () =>
{
var parametersWhere = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseRoleEntity.FieldDeleted, 0),
new KeyValuePair <string, object>(BaseRoleEntity.FieldEnabled, 1)
};
return(new BaseRoleManager(tableName).GetList <BaseRoleEntity>(parametersWhere, BaseRoleEntity.FieldId));
}, true, false, cacheTime);
result = listRole.Find(t => t.Name == name);
//直接读取数据库
//BaseRoleManager manager = new BaseRoleManager(tableName);
//result = manager.GetEntityByName(name);
return(result);
}
public static BaseRoleEntity GetObjectByCache(string systemCode, string id, bool fefreshCache = false)
{
BaseRoleEntity result = null;
if (string.IsNullOrWhiteSpace(systemCode))
{
systemCode = "Base";
}
string key = systemCode + ".Role";
if (!string.IsNullOrEmpty(id))
{
key = systemCode + ".Role." + id;
}
// 2016-02-29 吉日嘎拉，强制刷新缓存的方法改进。
if (!fefreshCache)
{
result = GetCacheByKey(key);
}
if (result == null)
{
// 动态读取表中的数据
string tableName = systemCode + "Role";
BaseRoleManager manager = new BaseRoleManager(tableName);
result = manager.GetObject(id);
// 若是空的不用缓存，继续读取实体
if (result != null)
{
SetCache(systemCode, result);
}
}
return result;
}
/// <summary>
/// 批量删除角色
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <returns>影响行数</returns>
public int BatchDelete(BaseUserInfo userInfo, string[] ids)
{
int result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDbWithTransaction(userInfo, parameter, (dbHelper) =>
{
string tableName = userInfo.SystemCode + "Role";
var manager = new BaseRoleManager(dbHelper, userInfo, tableName);
// 这里是直接删除功能的实现
// result = roleManager.BatchDelete(ids);
BaseRoleEntity roleEntity = null;
// 把删除的记录放到被删除的表里(表名后面加了后缀Deleted，也可以放在另外一个数据库里也可以的)
var roleDeletedManager = new BaseRoleManager(dbHelper, userInfo, tableName + "Deleted");
foreach (var id in ids)
{
// 逐个删除，逐个备份
roleEntity = manager.GetObject(id);
// 先添加到被删除的表里，这时候原先数据的主键需要保留的，否则恢复数据时可能会乱套
roleDeletedManager.Add(roleEntity);
// 数据备份好后再进行删除处理
result += manager.Delete(id);
}
});
return(result);
}
/// <summary>
/// 添加角色(同时添加用户，一个数据库事务里进行处理)
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="entity">实体</param>
/// <param name="userIds">用户主键数组</param>
/// <param name="status">状态</param>
/// <param name="statusMessage">返回状态信息</param>
/// <returns>主键</returns>
public string AddWithUser(BaseUserInfo userInfo, BaseRoleEntity entity, string[] userIds, out Status status, out string statusMessage)
{
var result = string.Empty;
var returnCode = Status.Ok;
var returnMessage = string.Empty;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDbWithTransaction(userInfo, parameter, (dbHelper) =>
{
// 这里是判断已经登录的用户是否有调用当前函数的权限，加强服务层被远程调用的安全性的
var tableName = userInfo.SystemCode + "Role";
var manager = new BaseRoleManager(dbHelper, userInfo, tableName);
result = manager.Add(entity, out returnCode);
if (!string.IsNullOrEmpty(result) && userIds != null && userIds.Length > 0)
{
tableName = userInfo.SystemCode + "UserRole";
var userManager = new BaseUserManager(dbHelper, userInfo, tableName);
// 小心异常，检查一下参数的有效性
if (userIds != null)
{
userManager.AddToRole(userInfo.SystemCode, userIds, new string[] { result });
}
}
returnMessage = manager.GetStateMessage(returnCode);
});
status = returnCode;
statusMessage = returnMessage;
return(result);
}
/// <summary>
/// 从缓存获取获取实体
/// </summary>
/// <param name="systemCode">系统编号</param>
/// <param name="realName">名称</param>
/// <returns>权限实体</returns>
public static BaseRoleEntity GetObjectByCacheByName(string systemCode, string realName)
{
BaseRoleEntity result = null;
if (string.IsNullOrWhiteSpace(systemCode))
{
systemCode = "Base";
}
string key = systemCode + ".Role";
if (!string.IsNullOrEmpty(realName))
{
key = systemCode + ".Role." + realName;
}
result = GetCacheByKey(key);
if (result == null)
{
// 动态读取表中的数据
string tableName = systemCode + "Role";
BaseRoleManager manager = new BaseRoleManager(tableName);
result = manager.GetObjectByName(realName);
// 若是空的不用缓存，继续读取实体
if (result != null)
{
SetCache(systemCode, result);
}
}
return result;
}
public BaseUserInfo ConvertToUserInfo(BaseUserEntity userEntity, BaseUserInfo userInfo)
{
userInfo.OpenId = userEntity.OpenId;
userInfo.Id = userEntity.Id.ToString();
userInfo.Code = userEntity.Code;
userInfo.UserName = userEntity.UserName;
userInfo.RealName = userEntity.RealName;
userInfo.RoleId = userEntity.RoleId;
userInfo.CompanyId = userEntity.CompanyId;
userInfo.CompanyName = userEntity.CompanyName;
userInfo.SubCompanyId = userEntity.SubCompanyId;
userInfo.SubCompanyName = userEntity.SubCompanyName;
userInfo.DepartmentId = userEntity.DepartmentId;
userInfo.DepartmentName = userEntity.DepartmentName;
userInfo.WorkgroupId = userEntity.WorkgroupId;
userInfo.WorkgroupName = userEntity.WorkgroupName;
if (userEntity.SecurityLevel == null)
{
userEntity.SecurityLevel = 0;
}
userInfo.SecurityLevel = (int)userEntity.SecurityLevel;
if (userEntity.RoleId != null)
{
// 获取角色名称
BaseRoleManager roleManager = new BaseRoleManager(DbHelper, UserInfo);
BaseRoleEntity roleEntity = roleManager.GetEntity(userEntity.RoleId);
if (roleEntity.Id > 0)
{
userInfo.RoleName = roleEntity.RealName;
}
}
return(userInfo);
}
public static BaseRoleEntity GetObject(BaseUserInfo userInfo, string systemCode, string id)
{
BaseRoleEntity result = null;
string url = BaseSystemInfo.UserCenterHost + "/UserCenterV42/RoleService.ashx";
WebClient webClient = new WebClient();
NameValueCollection postValues = new NameValueCollection();
postValues.Add("system", BaseSystemInfo.SoftFullName);
postValues.Add("systemCode", systemCode);
postValues.Add("securityKey", BaseSystemInfo.SecurityKey);
postValues.Add("function", "GetObject");
postValues.Add("userInfo", userInfo.Serialize());
postValues.Add("encrypted", true.ToString());
postValues.Add("id", SecretUtil.Encrypt(id));
// 向服务器发送POST数据
byte[] responseArray = webClient.UploadValues(url, postValues);
string response = Encoding.UTF8.GetString(responseArray);
if (!string.IsNullOrEmpty(response))
{
JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();
result = javaScriptSerializer.Deserialize <BaseRoleEntity>(response);
}
return(result);
}
/// <summary>
/// 保存实体修改记录
/// </summary>
/// <param name="newEntity">修改前的实体对象</param>
/// <param name="oldEntity">修改后的实体对象</param>
/// <param name="tableName">表名称</param>
public void UpdateEntityLog(BaseRoleEntity newEntity, BaseRoleEntity oldEntity, string tableName = null)
{
if (string.IsNullOrEmpty(tableName))
{
// tableName = this.CurrentTableName + "_LOG";
tableName = BaseModifyRecordEntity.TableName;
}
BaseModifyRecordManager manager = new BaseModifyRecordManager(this.UserInfo, tableName);
foreach (var property in typeof(BaseRoleEntity).GetProperties())
{
var oldValue = Convert.ToString(property.GetValue(oldEntity, null));
var newValue = Convert.ToString(property.GetValue(newEntity, null));
var fieldDescription = property.GetCustomAttributes(typeof(FieldDescription), false).FirstOrDefault() as FieldDescription;
//不记录创建人、修改人、没有修改的记录
if (!fieldDescription.NeedLog || oldValue == newValue)
{
continue;
}
var record = new BaseModifyRecordEntity();
record.ColumnCode = property.Name.ToUpper();
record.ColumnDescription = fieldDescription.Text;
record.NewValue = newValue;
record.OldValue = oldValue;
record.TableCode = this.CurrentTableName.ToUpper();
record.TableDescription = FieldExtensions.ToDescription(typeof(BaseRoleEntity), "TableName");
record.RecordKey = oldEntity.Id.ToString();
record.IPAddress = Utilities.GetIPAddress(true);
manager.Add(record, true, false);
}
}
/// <summary>
/// 添加角色
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="role">角色</param>
/// <returns>主键</returns>
public string AddRole(BaseUserInfo userInfo, string role)
{
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
string returnValue = string.Empty;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseRoleManager roleManager = new BaseRoleManager(dbHelper, userInfo);
string statusCode = string.Empty;
BaseRoleEntity roleEntity = new BaseRoleEntity();
roleEntity.RealName = role;
roleEntity.Enabled = 1;
returnValue = roleManager.Add(roleEntity, out statusCode);
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}
}
return(returnValue);
}
/// <summary>
/// 添加, 这里可以人工干预，提高程序的性能
/// </summary>
/// <param name="entity">实体</param>
/// <param name="identity">自增量方式，表主键是否采用自增的策略</param>
/// <param name="returnId">返回主键，不返回程序允许速度会快，主要是为了主细表批量插入数据优化用的</param>
/// <returns>主键</returns>
public string Add(BaseRoleEntity entity, bool identity = true, bool returnId = true)
{
Identity = identity;
ReturnId = returnId;
entity.Id = AddEntity(entity).ToInt();
return(entity.Id.ToString());
}
/// <summary>
/// 添加角色
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="entity">实体</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状态信息</param>
/// <returns>主键</returns>
public string Add(BaseUserInfo userInfo, BaseRoleEntity entity, out string statusCode, out string statusMessage)
{
string result = string.Empty;
string returnCode = string.Empty;
string returnMessage = string.Empty;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDbWithTransaction(userInfo, parameter, (dbHelper) =>
{
// 这里是判断已经登录的用户是否有调用当前函数的权限，加强服务层被远程调用的安全性的，会损失服务器的性能
// var permissionManager = new BasePermissionManager(result);
// if (permissionManager.CheckPermissionByUser(result.Id, "RoleAdmin.Add", "添加角色"))
// {
string tableName = userInfo.SystemCode + "Role";
var manager = new BaseRoleManager(dbHelper, userInfo, tableName);
result = manager.Add(entity, out returnCode);
returnMessage = manager.GetStateMessage(returnCode);
// }
//else
//{
// StatusCode = Status.AccessDeny.ToString();
// permissionManager.GetStateMessage(StatusCode);
//}
});
statusCode = returnCode;
statusMessage = returnMessage;
return(result);
}
/// <summary>
/// 缓存预热,强制重新缓存
/// 2016-02-26 每个角色的权限也进行缓存起来
/// </summary>
/// <param name="systemCode">系统编号</param>
/// <returns>影响行数</returns>
public static int CachePreheating(string systemCode)
{
int result = 0;
// 把所有的组织机构都缓存起来的代码
BaseRoleManager manager = new BaseRoleManager();
manager.CurrentTableName = systemCode + "Role";
using (IDataReader dataReader = manager.ExecuteReader())
{
while (dataReader.Read())
{
BaseRoleEntity entity = BaseEntity.Create <BaseRoleEntity>(dataReader, false);
if (entity != null)
{
// 设置角色本身的缓存
BaseRoleManager.SetCache(systemCode, entity);
// 重置权限缓存数据
BaseRolePermissionManager.ResetPermissionByCache(systemCode, entity.Id);
result++;
System.Console.WriteLine(result.ToString() + " : " + entity.RealName);
}
}
dataReader.Close();
}
return(result);
}
public bool IsAdministrator(string userId)
{
// 用户是超级管理员
if (userId.Equals("Administrator"))
{
return(true);
}
BaseUserEntity userEntity = this.GetEntity(userId);
if (userEntity.Code != null && userEntity.Code.Equals("Administrator"))
{
return(true);
}
if (userEntity.UserName != null && userEntity.UserName.Equals("Administrator"))
{
return(true);
}
string tableName = BaseUserRoleEntity.TableName;
if (!string.IsNullOrEmpty(BaseSystemInfo.SystemCode))
{
tableName = BaseSystemInfo.SystemCode + "Role";
}
// 用户的默认角色是超级管理员
BaseRoleManager roleManager = new BaseRoleManager(this.DbHelper, this.UserInfo, tableName);
// 用户默认角色是否为超级管理员
BaseRoleEntity roleEntity = null;
if (userEntity.RoleId != null)
{
roleEntity = roleManager.GetEntity(userEntity.RoleId);
if (roleEntity.Code != null && roleEntity.Code.Equals(DefaultRole.Administrators.ToString()))
{
return(true);
}
}
// 用户在超级管理员群里
string[] roleIds = this.GetAllRoleIds(userId);
for (int i = 0; i < roleIds.Length; i++)
{
if (roleIds[i].Equals(DefaultRole.Administrators.ToString()))
{
return(true);
}
roleEntity = roleManager.GetEntity(roleIds[i]);
if (roleEntity.Code != null && roleEntity.Code.Equals(DefaultRole.Administrators.ToString()))
{
return(true);
}
}
return(false);
}
/// <summary>
/// 从缓存中获取
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static BaseRoleEntity GetCacheByKey(string key)
{
BaseRoleEntity result = null;
if (!string.IsNullOrWhiteSpace(key))
{
result = CacheUtil.Get <BaseRoleEntity>(key);
}
return(result);
}
/// <summary>
/// 检查唯一值式新增
/// </summary>
/// <param name="entity">实体</param>
/// <param name="status">状态</param>
/// <returns></returns>
public string UniqueAdd(BaseRoleEntity entity, out Status status)
{
var result = string.Empty;
//检查是否重复
var parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseRoleEntity.FieldSystemCode, entity.SystemCode),
new KeyValuePair <string, object>(BaseRoleEntity.FieldName, entity.Name),
new KeyValuePair <string, object>(BaseRoleEntity.FieldEnabled, 1),
new KeyValuePair <string, object>(BaseRoleEntity.FieldDeleted, 0)
};
//检查是否重复
var parametersCode = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseRoleEntity.FieldSystemCode, entity.SystemCode),
new KeyValuePair <string, object>(BaseRoleEntity.FieldCode, entity.Code),
new KeyValuePair <string, object>(BaseRoleEntity.FieldEnabled, 1),
new KeyValuePair <string, object>(BaseRoleEntity.FieldDeleted, 0)
};
if (!IsUnique(parameters, entity.Id.ToString()))
{
//名称已重复
Status = Status.ErrorNameExist;
StatusCode = Status.ErrorNameExist.ToString();
StatusMessage = Status.ErrorNameExist.ToDescription();
}
else if (!IsUnique(parametersCode, entity.Id.ToString()))
{
//名称已重复
Status = Status.ErrorCodeExist;
StatusCode = Status.ErrorCodeExist.ToString();
StatusMessage = Status.ErrorCodeExist.ToDescription();
}
else
{
result = AddEntity(entity);
if (!string.IsNullOrEmpty(result))
{
Status = Status.OkAdd;
StatusCode = Status.OkAdd.ToString();
StatusMessage = Status.OkAdd.ToDescription();
}
else
{
Status = Status.Error;
StatusCode = Status.Error.ToString();
StatusMessage = Status.Error.ToDescription();
}
}
status = Status;
return(result);
}
/// <summary>
/// 获取实体
/// </summary>
/// <param name="code">编号</param>
/// <returns>实体</returns>
public BaseRoleEntity GetObjectByCode(string code)
{
BaseRoleEntity result = null;
List<KeyValuePair<string, object>> parameters = new List<KeyValuePair<string, object>>();
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldCode, code));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldDeletionStateCode, 0));
result = BaseEntity.Create<BaseRoleEntity>(this.ExecuteReader(parameters));
return result;
}
/// <summary>
/// 通过编号获取主键
/// </summary>
/// <param name="systemCode">系统编号</param>
/// <param name="code">编号</param>
/// <returns>显示值</returns>
public static string GetIdByCodeByCache(string systemCode, string code)
{
string result = string.Empty;
BaseRoleEntity entity = GetObjectByCacheByCode(systemCode, code);
if (entity != null)
{
result = entity.Id;
}
return result;
}
/// <summary>
/// 通过主键获取名称
/// 这里是进行了内存缓存处理，减少数据库的I/O处理，提高程序的运行性能，
/// 若有数据修改过，重新启动一下程序就可以了，这些基础数据也不是天天修改来修改去的，
/// 所以没必要过度担忧，当然有需要时也可以写个刷新缓存的程序
/// </summary>
/// <param name="systemCode">系统编号</param>
/// <param name="id">主键</param>
/// <returns>显示值</returns>
public static string GetRealNameByCache(string systemCode, string id)
{
string result = string.Empty;
BaseRoleEntity entity = GetObjectByCache("Base", id);
if (entity != null)
{
result = entity.RealName;
}
return result;
}
/// <summary>
/// 添加或更新(主键是否为0)
/// </summary>
/// <param name="entity">实体</param>
/// <param name="identity">自增量方式，表主键是否采用自增的策略</param>
/// <param name="returnId">返回主键，不返回程序允许速度会快，主要是为了主细表批量插入数据优化用的</param>
/// <returns>主键</returns>
public string AddOrUpdate(BaseRoleEntity entity, bool identity = true, bool returnId = true)
{
Identity = identity;
ReturnId = returnId;
if (entity.Id == 0)
{
entity.Id = AddEntity(entity).ToInt();
return(entity.Id.ToString());
}
else
{
return(UpdateEntity(entity) > 0 ? entity.Id.ToString() : string.Empty);
}
}
/// <summary>
/// 获取实体
/// </summary>
/// <param name="code">编号</param>
/// <returns>实体</returns>
public BaseRoleEntity GetEntityByCode(string code)
{
BaseRoleEntity result = null;
var parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseRoleEntity.FieldCode, code),
new KeyValuePair <string, object>(BaseRoleEntity.FieldDeleted, 0)
};
result = BaseEntity.Create <BaseRoleEntity>(GetDataTable(parameters));
return(result);
}
public static BaseRoleEntity GetCacheByKey(string key)
{
BaseRoleEntity result = null;
if (!string.IsNullOrWhiteSpace(key))
{
using (var redisClient = PooledRedisHelper.GetClient())
{
result = redisClient.Get <BaseRoleEntity>(key);
}
}
return(result);
}
/// <summary>
/// 添加角色
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="roleEntity">实体</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状态信息</param>
/// <returns>主键</returns>
public string Add(BaseUserInfo userInfo, BaseRoleEntity roleEntity, out string statusCode, out string statusMessage)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
string returnValue = string.Empty;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
dbHelper.BeginTransaction();
string tableName = BaseRoleEntity.TableName;
if (!string.IsNullOrEmpty(BaseSystemInfo.SystemCode))
{
tableName = BaseSystemInfo.SystemCode + "Role";
}
BaseRoleManager roleManager = new BaseRoleManager(dbHelper, userInfo, tableName);
returnValue = roleManager.Add(roleEntity, out statusCode);
statusMessage = roleManager.GetStateMessage(statusCode);
BaseLogManager.Instance.Add(dbHelper, userInfo, serviceName, AppMessage.RoleService_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>
/// 通过编号获取选项的显示内容
/// 这里是进行了内存缓存处理，减少数据库的I/O处理，提高程序的运行性能，
/// 若有数据修改过，重新启动一下程序就可以了，这些基础数据也不是天天修改来修改去的，
/// 所以没必要过度担忧，当然有需要时也可以写个刷新缓存的程序
/// </summary>
/// <param name="id">主键</param>
/// <returns>显示值</returns>
public static string GetRealName(string id)
{
string result = id;
if (!string.IsNullOrEmpty(id))
{
List <BaseRoleEntity> entityList = GetObjectList();
BaseRoleEntity roleEntity = entityList.FirstOrDefault(entity => entity.Id.HasValue && entity.Id.ToString().Equals(id));
if (roleEntity != null)
{
result = roleEntity.RealName;
}
}
return(result);
}
public static BaseRoleEntity GetCache(string key)
{
BaseRoleEntity result = null;
if (!string.IsNullOrWhiteSpace(key))
{
System.Web.Caching.Cache cache = HttpRuntime.Cache;
if (cache != null && cache[key] == null)
{
result = cache[key] as BaseRoleEntity;
}
}
return(result);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="roleEntity">实体</param>
private void SetEntity(SQLBuilder sqlBuilder, BaseRoleEntity roleEntity)
{
sqlBuilder.SetValue(BaseRoleEntity.FieldSystemId, roleEntity.SystemId);
sqlBuilder.SetValue(BaseRoleEntity.FieldOrganizeId, roleEntity.OrganizeId);
sqlBuilder.SetValue(BaseRoleEntity.FieldCode, roleEntity.Code);
sqlBuilder.SetValue(BaseRoleEntity.FieldRealName, roleEntity.RealName);
sqlBuilder.SetValue(BaseRoleEntity.FieldCategoryCode, roleEntity.CategoryCode);
sqlBuilder.SetValue(BaseRoleEntity.FieldAllowEdit, roleEntity.AllowEdit);
sqlBuilder.SetValue(BaseRoleEntity.FieldAllowDelete, roleEntity.AllowDelete);
sqlBuilder.SetValue(BaseRoleEntity.FieldSortCode, roleEntity.SortCode);
sqlBuilder.SetValue(BaseRoleEntity.FieldDeletionStateCode, roleEntity.DeletionStateCode);
sqlBuilder.SetValue(BaseRoleEntity.FieldEnabled, roleEntity.Enabled);
sqlBuilder.SetValue(BaseRoleEntity.FieldDescription, roleEntity.Description);
SetEntityExpand(sqlBuilder, roleEntity);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="entity">实体</param>
private void SetObject(SQLBuilder sqlBuilder, BaseRoleEntity entity)
{
sqlBuilder.SetValue(BaseRoleEntity.FieldOrganizeId, entity.OrganizeId);
sqlBuilder.SetValue(BaseRoleEntity.FieldCode, entity.Code);
sqlBuilder.SetValue(BaseRoleEntity.FieldRealName, entity.RealName);
sqlBuilder.SetValue(BaseRoleEntity.FieldCategoryCode, entity.CategoryCode);
sqlBuilder.SetValue(BaseRoleEntity.FieldAllowEdit, entity.AllowEdit);
sqlBuilder.SetValue(BaseRoleEntity.FieldAllowDelete, entity.AllowDelete);
sqlBuilder.SetValue(BaseRoleEntity.FieldSortCode, entity.SortCode);
sqlBuilder.SetValue(BaseRoleEntity.FieldDeletionStateCode, entity.DeletionStateCode);
sqlBuilder.SetValue(BaseRoleEntity.FieldEnabled, entity.Enabled);
sqlBuilder.SetValue(BaseRoleEntity.FieldIsVisible, entity.IsVisible);
sqlBuilder.SetValue(BaseRoleEntity.FieldDescription, entity.Description);
SetObjectExpand(sqlBuilder, entity);
}
/// <summary>
/// 更新实体
/// </summary>
/// <param name="entity">实体</param>
public int UpdateObject(BaseRoleEntity entity)
{
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper);
sqlBuilder.BeginUpdate(this.CurrentTableName);
this.SetObject(sqlBuilder, entity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseRoleEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseRoleEntity.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseRoleEntity.FieldModifiedOn);
sqlBuilder.SetWhere(BaseRoleEntity.FieldId, entity.Id);
return(sqlBuilder.EndUpdate());
}
/// <summary>
/// 获取实体
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="id">主键</param>
/// <returns>实体</returns>
public BaseRoleEntity GetObject(BaseUserInfo userInfo, string id)
{
BaseRoleEntity result = null;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
string tableName = userInfo.SystemCode + "Role";
var manager = new BaseRoleManager(dbHelper, userInfo, tableName);
result = manager.GetObject(id);
});
return(result);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="sqlBuilder">Sql语句生成器</param>
/// <param name="entity">实体</param>
private void SetEntity(SqlBuilder sqlBuilder, BaseRoleEntity entity)
{
SetEntityExtend(sqlBuilder, entity);
sqlBuilder.SetValue(BaseRoleEntity.FieldSystemCode, entity.SystemCode);
sqlBuilder.SetValue(BaseRoleEntity.FieldOrganizationId, entity.OrganizationId);
sqlBuilder.SetValue(BaseRoleEntity.FieldCode, entity.Code);
sqlBuilder.SetValue(BaseRoleEntity.FieldName, entity.Name);
sqlBuilder.SetValue(BaseRoleEntity.FieldCategoryCode, entity.CategoryCode);
sqlBuilder.SetValue(BaseRoleEntity.FieldAllowEdit, entity.AllowEdit);
sqlBuilder.SetValue(BaseRoleEntity.FieldAllowDelete, entity.AllowDelete);
sqlBuilder.SetValue(BaseRoleEntity.FieldIsVisible, entity.IsVisible);
sqlBuilder.SetValue(BaseRoleEntity.FieldDescription, entity.Description);
sqlBuilder.SetValue(BaseRoleEntity.FieldSortCode, entity.SortCode);
sqlBuilder.SetValue(BaseRoleEntity.FieldDeleted, entity.Deleted);
sqlBuilder.SetValue(BaseRoleEntity.FieldEnabled, entity.Enabled);
}
