/// <summary>
/// 批量更新通讯地址
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="dt">数据表</param>
/// <returns>影响行数</returns>
public int BatchUpdateAddress(BaseUserInfo userInfo, DataTable dt)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
// 这里是只更新部分字段的例子
foreach (DataRow dr in dt.Rows)
{
var sqlBuilder = new SqlBuilder(dbHelper);
sqlBuilder.BeginUpdate(BaseStaffEntity.CurrentTableName);
// 这里是界面上显示的字段，需要更新的字段
sqlBuilder.SetValue(BaseStaffEntity.FieldOfficePhone, dr[BaseStaffEntity.FieldOfficePhone].ToString());
sqlBuilder.SetValue(BaseStaffEntity.FieldExtension, dr[BaseStaffEntity.FieldExtension].ToString());
sqlBuilder.SetValue(BaseStaffEntity.FieldMobile, dr[BaseStaffEntity.FieldMobile].ToString());
sqlBuilder.SetValue(BaseStaffEntity.FieldShortNumber, dr[BaseStaffEntity.FieldShortNumber].ToString());
sqlBuilder.SetValue(BaseStaffEntity.FieldEmail, dr[BaseStaffEntity.FieldEmail].ToString());
sqlBuilder.SetValue(BaseStaffEntity.FieldQq, dr[BaseStaffEntity.FieldQq].ToString());
sqlBuilder.SetValue(BaseStaffEntity.FieldDescription, dr[BaseStaffEntity.FieldDescription].ToString());
sqlBuilder.SetWhere(BaseStaffEntity.FieldId, dr[BaseStaffEntity.FieldId].ToString());
result += sqlBuilder.EndUpdate();
}
});
return(result);
}
/// <summary>
/// 员工关联用户
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="staffId">员工主键</param>
/// <param name="userId">用户主键</param>
/// <returns>影响行数</returns>
public int SetStaffUser(BaseUserInfo userInfo, string staffId, string userId)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseStaffManager(dbHelper, userInfo);
if (ValidateUtil.IsInt(userId))
{
result = manager.SetProperty(staffId, new KeyValuePair <string, object>(BaseStaffEntity.FieldUserId, userId));
}
else
{
// 一个用户只能帮定到一个帐户上，检查是否已经绑定过这个用户了。
var staffIds = manager.GetIds(new KeyValuePair <string, object>(BaseStaffEntity.FieldUserId, userId), new KeyValuePair <string, object>(BaseStaffEntity.FieldDeleted, 0));
if (staffIds == null || staffIds.Length == 0)
{
result = manager.SetProperty(staffId, new KeyValuePair <string, object>(BaseStaffEntity.FieldUserId, userId));
var userManager = new BaseUserManager(dbHelper, userInfo);
var userEntity = userManager.GetEntity(userId);
result = manager.SetProperty(staffId, new KeyValuePair <string, object>(BaseStaffEntity.FieldUserName, userEntity.UserName));
}
}
});
return(result);
}
/// <summary>
/// 某个用户是否对某个模块Url有访问权限
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userId">用户主键</param>
/// <param name="moduleUrl">模块Url</param>
/// <returns>是否有权限</returns>
public bool IsUrlAuthorizedByUser(BaseUserInfo userInfo, string userId, string moduleUrl)
{
var result = false;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
// 是否超级管理员
// 是超级管理员,就不用继续判断权限了
var userEntity = BaseUserManager.GetEntityByCache(userId);
if (userEntity != null)
{
result = BaseUserManager.IsAdministrator(userId);
if (!result)
{
var tableName = userInfo.SystemCode + "Module";
var moduleManager = new BaseModuleManager(dbHelper, userInfo, tableName);
List <BaseModuleEntity> entityList = null;
// moduleManager.GetList(userId);
// 这里需要改进，只读到第一个就可以返回了，没必要全部列表都计算一边
var count = entityList.Count(entity => !string.IsNullOrEmpty(entity.NavigateUrl) &&
(entity.NavigateUrl.Equals(moduleUrl, StringComparison.OrdinalIgnoreCase) || moduleUrl.StartsWith(entity.NavigateUrl)));
result = count > 0;
}
}
});
return(result);
}
/// <summary>
/// 下载文件
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="id">主键</param>
/// <returns>文件</returns>
public byte[] Downloads(BaseUserInfo userInfo, string id)
{
byte[] result = null;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseFileManager(dbHelper, userInfo);
if (BaseSystemInfo.UploadStorageMode == "Disk")
{
manager.UpdateReadCount(id); // 阅读次数要加一
BaseFileEntity entity = manager.GetObject(id);
System.IO.FileStream fs = null;
//建立二进制读取
System.IO.BinaryReader br = null;
fs = new FileStream(entity.FilePath + entity.FileName, System.IO.FileMode.Open);
br = new BinaryReader((Stream)fs);
result = br.ReadBytes((int)fs.Length);
br.Close();
fs.Close();
}
else
{
result = manager.Download(id);
}
});
return(result);
}
/// <summary>
/// 获取角色列表
/// </summary>
/// <param name="systemCode">系统编号</param>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public DataTable GetDataTable(BaseUserInfo userInfo, string systemCode)
{
var result = new DataTable(BaseRoleEntity.CurrentTableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var tableName = systemCode + "Role";
// 获得角色列表
var manager = new BaseRoleManager(dbHelper, userInfo, tableName);
var parameters = new List <KeyValuePair <string, object> >();
// parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldDeleted, 0));
// parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldEnabled, 1)); //如果1 只显示有效用户
// parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldIsVisible, 1));
// dt = manager.GetDataTable(parameters, BaseRoleEntity.FieldSortCode);
result = manager.GetDataTable(0, BaseRoleEntity.FieldSortCode);
result.TableName = tableName;
if (!userInfo.SystemCode.Equals("Base", StringComparison.OrdinalIgnoreCase))
{
manager = new BaseRoleManager(dbHelper, userInfo);
parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseRoleEntity.FieldCategoryCode, "SystemRole"),
new KeyValuePair <string, object>(BaseRoleEntity.FieldDeleted, 0),
new KeyValuePair <string, object>(BaseRoleEntity.FieldEnabled, 1)
};
var dtBase = manager.GetDataTable(parameters);
result.Merge(dtBase, true);
}
});
return(result);
}
/// <summary>
/// 获取城市
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="province">省份</param>
/// <returns>城市数组</returns>
public string[] GetCity(BaseUserInfo userInfo, string province)
{
string[] result = null;
#if Redis
result = BaseOrganizeManager.GetCityByCache(province);
#else
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
System.Web.Caching.Cache cache = HttpRuntime.Cache;
string cacheObject = "AreaOrganizeCity" + province;
if (cache != null && cache[cacheObject] == null)
{
// BaseAreaManager areaManager = new BaseAreaManager(dbHelper, result);
// result = areaManager.GetCityList(provinceId);
var manager = new BaseOrganizeManager(dbHelper, userInfo);
result = manager.GetCity(province);
cache.Add(cacheObject, result, null, DateTime.Now.AddHours(8), TimeSpan.Zero, CacheItemPriority.Normal, null);
}
result = cache[cacheObject] as string[];
});
#endif
return(result);
}
/// <summary>
/// 查询用户列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="recordCount">记录条数</param>
/// <param name="pageNo">第几页</param>
/// <param name="pageSize">每页显示条数</param>
/// <param name="permissionCode">操作权限</param>
/// <param name="conditions">条件</param>
/// <param name="sort">排序</param>
/// <returns>数据表</returns>
public DataTable SearchUserByPage(BaseUserInfo userInfo, out int recordCount, int pageNo, int pageSize, string permissionCode, string conditions, string sort = null)
{
var departmentId = string.Empty;
var myrecordCount = 0;
var dt = new DataTable(BaseUserEntity.CurrentTableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
if (SecretUtil.IsSqlSafe(conditions))
{
var userManager = new BaseUserManager(dbHelper, userInfo)
{
ShowUserLogonInfo = true
};
dt = userManager.SearchLogByPage(out myrecordCount, pageNo, pageSize, permissionCode, conditions, sort);
dt.TableName = BaseUserEntity.CurrentTableName;
}
else
{
// 记录注入日志
LogUtil.WriteLog("userInfo:" + userInfo.Serialize() + " " + conditions, "SqlSafe");
}
});
recordCount = myrecordCount;
return(dt);
}
/// <summary>
/// 获取业务角色列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public DataTable GetApplicationRole(BaseUserInfo userInfo)
{
var dt = new DataTable(BaseRoleEntity.CurrentTableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var tableName = BaseRoleEntity.CurrentTableName;
if (!string.IsNullOrEmpty(userInfo.SystemCode))
{
tableName = userInfo.SystemCode + "Role";
}
// 获得角色列表
var manager = new BaseRoleManager(dbHelper, userInfo, tableName);
var parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseRoleEntity.FieldCategoryCode, "ApplicationRole"),
new KeyValuePair <string, object>(BaseRoleEntity.FieldDeleted, 0),
new KeyValuePair <string, object>(BaseRoleEntity.FieldIsVisible, 1)
};
dt = manager.GetDataTable(parameters, BaseRoleEntity.FieldSortCode);
dt.TableName = tableName;
});
return(dt);
}
/// <summary>
/// 按日期获取日志
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="beginDate">开始时间</param>
/// <param name="endDate">结束时间</param>
/// <param name="userId">用户Id</param>
/// <param name="moduleId">模块Id</param>
/// <param name="processId">日志类型</param>
/// <returns></returns>
public DataTable GetDataTableByDate(BaseUserInfo userInfo, string beginDate, string endDate, string userId, string moduleId, string processId = null)
{
var dt = new DataTable(BaseLogEntity.CurrentTableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
// var logManager = new BaseLogManager(dbHelper, result);
if (!string.IsNullOrEmpty(userId))
{
// dt = logManager.GetDataTableByDateByUserIds(new string[] { userId }, BaseLogEntity.FieldProcessId, moduleId, beginDate, endDate, processId);
}
else
{
if (BaseUserManager.IsAdministrator(userInfo.Id.ToString()))
{
// dt = logManager.GetDataTableByDate(BaseLogEntity.FieldProcessId, moduleId, beginDate, endDate, processId);
}
else
{
var basePermissionScopeManager = new BasePermissionScopeManager(dbHelper, userInfo);
var userIds = basePermissionScopeManager.GetUserIds(userInfo.SystemCode, userInfo.Id.ToString(), "Resource.ManagePermission");
// dt = logManager.GetDataTableByDateByUserIds(userIds, BaseLogEntity.FieldProcessId, moduleId, beginDate, endDate, processId);
}
}
dt.TableName = BaseLogEntity.CurrentTableName;
});
return(dt);
}
/// <summary>
/// 获取角色的权限范围列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="roleId">角色主键</param>
/// <param name="result">操作权限主键</param>
/// <returns>权限范围列表</returns>
public List <BasePermissionScopeEntity> GetRolePermissionScopeList(BaseUserInfo userInfo, string roleId, string permissionId)
{
List <BasePermissionScopeEntity> result = new List <BasePermissionScopeEntity>();
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
string roleTableName = BaseRoleEntity.TableName;
if (userInfo != null && !string.IsNullOrEmpty(userInfo.SystemCode))
{
roleTableName = userInfo.SystemCode + "Role";
}
List <KeyValuePair <string, object> > parameters = new List <KeyValuePair <string, object> >();
parameters.Add(new KeyValuePair <string, object>(BasePermissionScopeEntity.FieldResourceCategory, roleTableName));
parameters.Add(new KeyValuePair <string, object>(BasePermissionScopeEntity.FieldResourceId, roleId));
parameters.Add(new KeyValuePair <string, object>(BasePermissionScopeEntity.FieldPermissionId, permissionId));
parameters.Add(new KeyValuePair <string, object>(BasePermissionScopeEntity.FieldEnabled, 1));
parameters.Add(new KeyValuePair <string, object>(BasePermissionScopeEntity.FieldDeletionStateCode, 0));
string tableName = userInfo.SystemCode + "PermissionScope";
BasePermissionScopeManager permissionScopeManager = new BasePermissionScopeManager(dbHelper, userInfo, tableName);
result = permissionScopeManager.GetList <BasePermissionScopeEntity>(parameters);
});
return(result);
}
/// <summary>
/// 撤消资源的权限
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="resourceCategory">资源分类</param>
/// <param name="resourceId">资源主键</param>
/// <param name="revokePermissionIds">权限主键</param>
/// <returns>影响的行数</returns>
public int RevokeResourcePermission(BaseUserInfo userInfo, string resourceCategory, string resourceId, string[] revokePermissionIds)
{
int result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
// BaseRoleScopeManager manager = new BaseRoleScopeManager(dbHelper, result);
// 小心异常，检查一下参数的有效性
if (revokePermissionIds != null)
{
var permissionManager = new BasePermissionManager(dbHelper, userInfo);
for (int i = 0; i < revokePermissionIds.Length; i++)
{
List <KeyValuePair <string, object> > parameters = new List <KeyValuePair <string, object> >();
parameters.Add(new KeyValuePair <string, object>(BasePermissionEntity.FieldResourceCategory, resourceCategory));
parameters.Add(new KeyValuePair <string, object>(BasePermissionEntity.FieldResourceId, resourceId));
parameters.Add(new KeyValuePair <string, object>(BasePermissionEntity.FieldPermissionId, revokePermissionIds[i]));
// result += permissionManager.SetDeleted(parameters);
result += permissionManager.Delete(parameters);
}
}
});
return(result);
}
/// <summary>
/// 分页查询
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="recordCount">记录数</param>
/// <param name="pageNo">当前页</param>
/// <param name="pageSize">每页显示</param>
/// <param name="condition">条件</param>
/// <param name="dbParameters">参数</param>
/// <param name="order">排序</param>
/// <returns>数据表</returns>
public DataTable GetDataTableByPage(BaseUserInfo userInfo, out int recordCount, int pageNo, int pageSize, string condition, List <KeyValuePair <string, object> > dbParameters, string order = null)
{
var result = new DataTable(BaseUserEntity.CurrentTableName);
var myRecordCount = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
if (SecretUtil.IsSqlSafe(condition))
{
var userManager = new BaseUserManager(dbHelper, userInfo)
{
ShowUserLogonInfo = false
};
result = userManager.GetDataTableByPage(out myRecordCount, pageNo, pageSize, condition, dbHelper.MakeParameters(dbParameters), order);
result.TableName = BaseUserEntity.CurrentTableName;
}
else
{
// 记录注入日志
LogUtil.WriteLog("userInfo:" + userInfo.Serialize() + " " + condition, "SqlSafe");
}
});
recordCount = myRecordCount;
return(result);
}
/// <summary>
/// 分页查询
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="recordCount">记录数</param>
/// <param name="pageIndex">当前页</param>
/// <param name="pageSize">每页显示</param>
/// <param name="whereClause">条件</param>
/// <param name="dbParameters">参数</param>
/// <param name="order">排序</param>
/// <returns>数据表</returns>
public DataTable GetDataTableByPage(BaseUserInfo userInfo, out int recordCount, int pageIndex, int pageSize, string whereClause, List <KeyValuePair <string, object> > dbParameters, string order = null)
{
var result = new DataTable(BaseUserEntity.TableName);
int myRecordCount = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
if (SecretUtil.IsSqlSafe(whereClause))
{
var userManager = new BaseUserManager(dbHelper, userInfo);
userManager.ShowUserLogOnInfo = false;
result = userManager.GetDataTableByPage(out myRecordCount, pageIndex, pageSize, whereClause, dbHelper.MakeParameters(dbParameters), order);
result.TableName = BaseUserEntity.TableName;
}
else
{
if (System.Web.HttpContext.Current != null)
{
// 记录注入日志
FileUtil.WriteMessage("userInfo:" + userInfo.Serialize() + " " + whereClause, System.Web.HttpContext.Current.Server.MapPath("~/Log/") + "SqlSafe" + DateTime.Now.ToString(BaseSystemInfo.DateFormat) + ".txt");
}
}
});
recordCount = myRecordCount;
return(result);
}
/// <summary>
/// 按操作权限获取列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="tableName">目标表</param>
/// <param name="permissionCode">操作权限</param>
/// <returns>数据表</returns>
public DataTable GetDataTableByPermission(BaseUserInfo userInfo, string tableName, string permissionCode = "Resource.ManagePermission")
{
DataTable result = null;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var itemDetailsManager = new BaseDictionaryItemManager(dbHelper, userInfo, tableName);
// 管理员取得所有数据
if (BaseUserManager.IsAdministrator(userInfo.Id))
{
result = itemDetailsManager.GetDataTable(
new KeyValuePair <string, object>(BaseDictionaryItemEntity.FieldDeleted, 0)
, BaseDictionaryItemEntity.FieldSortCode);
}
else
{
// 管理时需要把所有的数据显示出来，所以无效的数据也需要显示的
// , new KeyValuePair<string, object>(BaseDictionaryItemEntity.FieldEnabled, 1)
// 按数据权限来过滤数据
var permissionScopeManager = new BasePermissionScopeManager(dbHelper, userInfo);
var ids = permissionScopeManager.GetResourceScopeIds(userInfo.SystemCode, userInfo.Id, tableName, permissionCode);
result = itemDetailsManager.GetDataTable(ids);
}
result.TableName = tableName;
});
return(result);
}
/// <summary>
/// 某个用户是否有相应的操作权限
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userId">用户主键</param>
/// <param name="permissionCode">权限编号</param>
/// <param name="permissionName">权限名称</param>
/// <returns>是否有权限</returns>
public bool IsAuthorized(BaseUserInfo userInfo, string userId, string permissionCode, string permissionName = null)
{
bool result = false;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
if (string.IsNullOrEmpty(userId))
{
userId = userInfo.Id;
}
#if (!DEBUG)
// 是超级管理员,就不用继续判断权限了
// var userManager = new BaseUserManager(result);
// result = userManager.IsAdministrator(userId);
#endif
if (!result)
{
var permissionManager = new BasePermissionManager(userInfo);
result = permissionManager.IsAuthorized(userInfo.SystemCode, userId, permissionCode, permissionName);
// BaseLogManager.Instance.Add(result, this.serviceName, AppMessage.PermissionService_IsAuthorized, MethodBase.GetCurrentMethod());
}
});
return(result);
}
/// <summary>
/// 获取用户的角色列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public DataTable GetRoleDataTable(BaseUserInfo userInfo)
{
var dt = new DataTable(BaseRoleEntity.CurrentTableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseRoleEntity.FieldEnabled, 1),
new KeyValuePair <string, object>(BaseRoleEntity.FieldDeleted, 0)
};
var roleManager = new BaseRoleManager(dbHelper, userInfo);
// 获取有效的，未必删除的数据，按排序码排序
dt = roleManager.GetDataTable(parameters, BaseRoleEntity.FieldSortCode);
// 不是超级管理员，不能添加超级管理员
if (!BaseUserManager.IsAdministrator(userInfo.Id.ToString()))
{
foreach (DataRow dr in dt.Rows)
{
if (dr[BaseRoleEntity.FieldCode].ToString().Equals(DefaultRole.Administrators.ToString()))
{
dr.Delete();
}
}
dt.AcceptChanges();
}
dt.TableName = BaseUserEntity.CurrentTableName;
dt.DefaultView.Sort = BaseUserEntity.FieldSortCode;
});
return(dt);
}
/// <summary>
/// 根据部门查询用户列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="permissionCode">权限编号</param>
/// <param name="searchValue">查询</param>
/// <param name="auditStates">有效</param>
/// <param name="roleIds">用户角色</param>
/// <param name="departmentId">部门主键</param>
/// <returns>数据表</returns>
public DataTable SearchByPageByDepartment(BaseUserInfo userInfo, string permissionCode, string searchValue, bool?enabled, string auditStates, string[] roleIds, bool showRole, bool userAllInformation, out int recordCount, int pageIndex = 0, int pageSize = 100, string sort = null, string departmentId = null)
{
var result = new DataTable(BaseUserEntity.TableName);
if (departmentId == null)
{
departmentId = string.Empty;
}
int myRecordCount = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var userManager = new BaseUserManager(dbHelper, userInfo);
userManager.ShowUserLogOnInfo = false;
result = userManager.SearchByPage(userInfo.SystemCode, permissionCode, searchValue, roleIds, enabled, auditStates, null, departmentId, showRole, userAllInformation, false, out myRecordCount, pageIndex, pageSize, sort);
result.TableName = BaseUserEntity.TableName;
// 是否显示角色信息
if (showRole)
{
GetUserRoles(userInfo, dbHelper, result);
}
});
recordCount = myRecordCount;
return(result);
}
/// <summary>
/// 查询用户列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="recordCount">记录条数</param>
/// <param name="pageIndex">第几页</param>
/// <param name="pageSize">每页显示条数</param>
/// <param name="permissionCode">操作权限</param>
/// <param name="conditions">条件</param>
/// <param name="sort">排序</param>
/// <returns>数据表</returns>
public DataTable SearchUserByPage(BaseUserInfo userInfo, out int recordCount, int pageIndex, int pageSize, string permissionCode, string conditions, string sort = null)
{
string departmentId = string.Empty;
int myrecordCount = 0;
var dt = new DataTable(BaseUserEntity.TableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
if (SecretUtil.IsSqlSafe(conditions))
{
var userManager = new BaseUserManager(dbHelper, userInfo);
userManager.ShowUserLogOnInfo = true;
dt = userManager.SearchLogByPage(out myrecordCount, pageIndex, pageSize, permissionCode, conditions, sort);
dt.TableName = BaseUserEntity.TableName;
}
else
{
if (System.Web.HttpContext.Current != null)
{
// 记录注入日志
FileUtil.WriteMessage("userInfo:" + userInfo.Serialize() + " " + conditions, System.Web.HttpContext.Current.Server.MapPath("~/Log/") + "SqlSafe" + DateTime.Now.ToString(BaseSystemInfo.DateFormat) + ".txt");
}
}
});
recordCount = myrecordCount;
return(dt);
}
/// <summary>
/// 获取用户列表
/// 当用户非常多时，不需要显示角色
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="showRole">显示角色</param>
/// <returns>数据表</returns>
public DataTable GetDataTable(BaseUserInfo userInfo, bool showRole = true)
{
var result = new DataTable(BaseUserEntity.CurrentTableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
// 这里是获取用户列表
var userManager = new BaseUserManager(dbHelper, userInfo);
// 获取允许登录列表
var parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseUserEntity.FieldDeleted, 0),
new KeyValuePair <string, object>(BaseUserEntity.FieldEnabled, 1),
new KeyValuePair <string, object>(BaseUserEntity.FieldIsVisible, 1)
};
result = userManager.GetDataTable(parameters, BaseUserEntity.FieldSortCode);
// 是否显示角色信息
if (showRole)
{
// 这里是获取角色列表
var tableName = userInfo.SystemCode + "Role";
var roleManager = new BaseRoleManager(dbHelper, userInfo, tableName);
var dataTableRole = roleManager.GetDataTable();
if (!result.Columns.Contains("RoleName"))
{
result.Columns.Add("RoleName");
}
// 友善的显示属于多个角色的功能
var roleName = string.Empty;
foreach (DataRow dr in result.Rows)
{
roleName = string.Empty;
// 获取所在角色
var roleIds = userManager.GetRoleIds(dr[BaseUserEntity.FieldId].ToString());
if (roleIds != null)
{
for (var i = 0; i < roleIds.Length; i++)
{
roleName = roleName + BaseUtil.GetProperty(dataTableRole, roleIds[i], BaseRoleEntity.FieldName) + " ";
}
}
// 设置角色的名称
if (!string.IsNullOrEmpty(roleName))
{
dr["RoleName"] = roleName;
}
}
result.AcceptChanges();
}
result.TableName = BaseUserEntity.CurrentTableName;
});
return(result);
}
/// <summary>
/// 判断字段是否重复
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="parameters">字段名,字段值</param>
/// <param name="id">主键</param>
/// <returns>已存在</returns>
public bool Exists(BaseUserInfo userInfo, List <KeyValuePair <string, object> > parameters, string id)
{
bool result = false;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseManager(dbHelper, userInfo, BaseDepartmentEntity.TableName);
result = manager.Exists(parameters, id);
});
return(result);
}
/// <summary>
/// 用户是否在某个组织架构里的判断
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userId">用户主键</param>
/// <param name="organizationName">部门名称</param>
/// <returns>存在</returns>
public bool UserIsInOrganization(BaseUserInfo userInfo, string userId, string organizationName)
{
var result = false;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var userManager = new BaseUserManager(dbHelper, userInfo);
result = userManager.IsInOrganization(userId, organizationName);
});
return(result);
}
/// <summary>
/// 按名称获取实体
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="fullName">名称</param>
/// <returns>实体</returns>
public BaseOrganizeEntity GetObjectByName(BaseUserInfo userInfo, string fullName)
{
BaseOrganizeEntity entity = null;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseOrganizeManager(dbHelper, userInfo);
entity = manager.GetObjectByName(fullName);
});
return(entity);
}
public List <BaseItemDetailsEntity> GetListByTargetTable(BaseUserInfo userInfo, string tableName)
{
List <BaseItemDetailsEntity> result = new List <BaseItemDetailsEntity>();
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
result = this.GetListByTargetTable(dbHelper, userInfo, tableName);
});
return(result);
}
/// <summary>
/// 按编号获取列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="code">编号</param>
/// <returns>数据表</returns>
public DataTable GetDataTableByCode(BaseUserInfo userInfo, string code)
{
var dt = new DataTable(BaseItemDetailsEntity.TableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
dt = this.GetDataTableByCode(dbHelper, userInfo, code);
});
return(dt);
}
public List <BaseItemDetailsEntity> GetListByCode(BaseUserInfo userInfo, string code)
{
List <BaseItemDetailsEntity> entityList = new List <BaseItemDetailsEntity>();
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
entityList = this.GetListByCode(dbHelper, userInfo, code);
});
return(entityList);
}
/// <summary>
/// 获取街道
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="districtId">县区主键</param>
/// <returns>街道列表</returns>
public List <BaseAreaEntity> GetStreetList(BaseUserInfo userInfo, string districtId)
{
List <BaseAreaEntity> result = null;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
result = BaseAreaManager.GetListByParentByCache(districtId);
});
return(result);
}
/// <summary>
/// 获取省份
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>省份列表</returns>
public List <BaseAreaEntity> GetProvinceList(BaseUserInfo userInfo)
{
List <BaseAreaEntity> result = null;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
result = BaseAreaManager.GetProvinceByCache();
});
return(result);
}
/// <summary>
/// 按编号获取实体
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="code">编号</param>
/// <returns>实体</returns>
public BaseOrganizationEntity GetEntityByCode(BaseUserInfo userInfo, string code)
{
BaseOrganizationEntity entity = null;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseOrganizationManager(dbHelper, userInfo);
entity = manager.GetEntityByCode(code);
});
return(entity);
}
/// <summary>
/// 获取约束条件
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="resourceCategory">资源类别</param>
/// <param name="resourceId">资源主键</param>
/// <param name="tableName">表名</param>
/// <returns>约束条件</returns>
public string GetConstraint(BaseUserInfo userInfo, string resourceCategory, string resourceId, string tableName)
{
string result = string.Empty;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseTableColumnsManager(dbHelper, userInfo);
result = manager.GetConstraint(resourceCategory, resourceId, tableName);
});
return(result);
}
/// <summary>
/// 某个用户是否超级管理员
/// </summary>
/// <param name="result"></param>
/// <param name="userId"></param>
/// <returns>是超级管理员</returns>
public bool IsAdministratorByUser(BaseUserInfo userInfo, string userId)
{
bool result = false;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseUserManager(dbHelper, userInfo);
result = manager.IsAdministrator(userId);
});
return(result);
}