/// <summary>
/// 获取用户的角色列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public DataTable GetRoleDT(UserInfo userInfo)
{
var dataTable = new DataTable(PiRoleTable.TableName);
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.UserService_GetRoleDT);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var roleManager = new PiRoleManager(dbProvider, userInfo);
// 获取有效的，未必删除的数据，按排序码排序
string[] names = { PiRoleTable.FieldDeleteMark, PiRoleTable.FieldEnabled };
Object[] values = { 0, 1 };
dataTable = roleManager.GetDT(names, values, PiRoleTable.FieldSortCode);
// 不是超级管理员，不能添加超级管理员
if (!userInfo.IsAdministrator)
{
foreach (DataRow dataRow in dataTable.Rows.Cast <DataRow>().Where(dataRow => dataRow[PiRoleTable.FieldCode].ToString().Equals(DefaultRole.Administrators.ToString())))
{
dataRow.Delete();
}
dataTable.AcceptChanges();
}
dataTable.TableName = PiUserTable.TableName;
dataTable.DefaultView.Sort = PiUserTable.FieldSortCode;
});
return(dataTable);
}
/// <summary>
/// 批量物理删除角色
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <returns>影响的行数</returns>
public int BatchDelete(UserInfo userInfo, string[] ids)
{
var returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.RoleService_BatchDelete);
ServiceUtil.ProcessRDIWriteDbWithTran(userInfo, parameter, dbProvider =>
{
returnValue = new PiRoleManager(dbProvider, userInfo).BatchDelete(ids);
});
return(returnValue);
}
/// <summary>
/// 取得实体
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="id">主键</param>
/// <returns>实体</returns>
public PiRoleEntity GetEntity(UserInfo userInfo, string id)
{
PiRoleEntity entity = null;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.RoleService_GetEntity);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
entity = new PiRoleManager(dbProvider, userInfo).GetEntity(id);
});
return(entity);
}
/// <summary>
/// 物理刪除角色
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="id">主键</param>
/// <returns>受影响的行数</returns>
public int Delete(UserInfo userInfo, string id)
{
var returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.RoleService_Delete, "主键：" + id);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
returnValue = new PiRoleManager(dbProvider, userInfo).Delete(id);
});
return(returnValue);
}
/// <summary>
/// 根据条件获得角色列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="names">字段</param>
/// <param name="values">值</param>
/// <returns>数据表</returns>
public DataTable GetDTByValues(UserInfo userInfo, string[] names, string[] values)
{
var dataTable = new DataTable(PiRoleTable.TableName);
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.RoleService_GetDTByValues);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
dataTable = new PiRoleManager(dbProvider, userInfo).GetDT(names, values);
dataTable.TableName = PiRoleTable.TableName;
});
return(dataTable);
}
/// <summary>
/// 取得角色列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public DataTable GetDT(UserInfo userInfo)
{
var dataTable = new DataTable(PiRoleTable.TableName);
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.RoleService_GetDT);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
dataTable = new PiRoleManager(dbProvider, userInfo).GetDT(PiRoleTable.FieldDeleteMark, 0, PiRoleTable.FieldSortCode);
dataTable.TableName = PiRoleTable.TableName;
});
return(dataTable);
}
/// <summary>
/// 移动角色数据
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="id">主键</param>
/// <param name="targetOrganizeId">目标组织机构主键</param>
/// <returns>影响行数</returns>
public int MoveTo(UserInfo userInfo, string id, string targetOrganizeId)
{
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.RoleService_MoveTo);
int result = 0;
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, (dbProvider) =>
{
var manager = new PiRoleManager(dbProvider, userInfo, PiRoleTable.TableName);
result = manager.MoveTo(id, targetOrganizeId);
});
return(result);
}
/// <summary>
/// 根据部门查询用户分页列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="permissionScopeCode">权限代码</param>
/// <param name="searchValue">查询</param>
/// <param name="enabled">有效</param>
/// <param name="auditStates">审核状态</param>
/// <param name="roleIds">用户角色</param>
/// <param name="showRole">是否显示角色信息</param>
/// <param name="departmentId">部门主键</param>
/// <returns></returns>
public DataTable GetUserPageDTByDepartment(UserInfo userInfo, string permissionScopeCode, 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)
{
if (departmentId == null)
{
departmentId = string.Empty;
}
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.UserService_Search);
int myrecordCount = 0;
var dt = new DataTable(PiUserTable.TableName);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, (dbProvider) =>
{
var userManager = new PiUserManager(dbProvider, userInfo);
dt = userManager.SearchByPage(permissionScopeCode, searchValue, roleIds, enabled, auditStates, departmentId, showRole, userAllInformation, out myrecordCount, pageIndex, pageSize, sort);
dt.TableName = PiUserTable.TableName;
// 是否显示角色信息
if (showRole)
{
// 这里是获取角色列表
PiRoleManager roleManager = new PiRoleManager(dbProvider, userInfo);
DataTable dataTableRole = roleManager.GetDT();
if (!dt.Columns.Contains("RoleName"))
{
dt.Columns.Add("RoleName");
}
// 友善的显示属于多个角色的功能
string roleName = string.Empty;
foreach (DataRow dr in dt.Rows)
{
roleName = string.Empty;
// 获取所在角色
roleIds = userManager.GetRoleIds(dr[PiUserTable.FieldId].ToString());
if (roleIds != null)
{
for (int i = 0; i < roleIds.Length; i++)
{
roleName = roleName + BusinessLogic.GetProperty(dataTableRole, roleIds[i], PiRoleTable.FieldRealName) + ", ";
}
}
// 设置角色的名称
if (!string.IsNullOrEmpty(roleName))
{
roleName = roleName.Substring(0, roleName.Length - 2);
dr["RoleName"] = roleName;
}
}
dt.AcceptChanges();
}
});
recordCount = myrecordCount;
return(dt);
}
/// <summary>
/// 批量逻辑删除角色
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <returns>影响的行数</returns>
public int SetDeleted(UserInfo userInfo, string[] ids)
{
var returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.RoleService_SetDeleted);
ServiceUtil.ProcessRDIWriteDbWithTran(userInfo, parameter, dbProvider =>
{
//TODO:此处还应该把角色相应的权限，所拥有的用户等也做统一处理。
returnValue = new PiRoleManager(dbProvider, userInfo).SetDeleted(ids);
});
return(returnValue);
}
/// <summary>
/// 取得角色列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public List <PiRoleEntity> GetList(UserInfo userInfo)
{
List <PiRoleEntity> list = new List <PiRoleEntity>();
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.RoleService_GetDT);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
List <KeyValuePair <string, object> > parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(PiOrganizeTable.FieldDeleteMark, 0)
};
list = new PiRoleManager(dbProvider, userInfo).GetList <PiRoleEntity>(parameters, PiRoleTable.FieldSortCode);
});
return(list);
}
/// <summary>
/// 撤消指定角色的操作权限
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="roleName">角色名</param>
/// <param name="permissionItemCode">撤消的操作权限编号</param>
/// <returns>主键</returns>
public int RevokeRolePermission(UserInfo userInfo, string roleName, string permissionItemCode)
{
var returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, string.Empty);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var roleId = new PiRoleManager(dbProvider, userInfo).GetId(PiRoleTable.FieldRealName, roleName);
var permissionItemId = new PiPermissionItemManager(dbProvider, userInfo).GetId(PiPermissionItemTable.FieldCode, permissionItemCode);
if (!String.IsNullOrEmpty(roleId) && !String.IsNullOrEmpty(permissionItemId))
{
returnValue = new RolePermissionManager(dbProvider, userInfo).Revoke(roleId, permissionItemId);
}
});
return(returnValue);
}
/// <summary>
/// 更新实体
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="entity">实体</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状态信息</param>
/// <returns>影响的行数</returns>
public int Update(UserInfo userInfo, PiRoleEntity entity, out string statusCode, out string statusMessage)
{
int returnValue = 0;
string returnCode = string.Empty;
string returnMessage = string.Empty;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.RoleService_Update);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var manager = new PiRoleManager(dbProvider, userInfo);
returnValue = manager.UpdateEntity(entity, out returnCode);
returnMessage = manager.GetStateMessage(returnCode);
});
statusCode = returnCode;
statusMessage = returnMessage;
return(returnValue);
}
public bool IsAdministrator(PiUserEntity entity)
{
// 用户是超级管理员
if (entity.Id.Equals("Administrator"))
{
return(true);
}
if (entity.Code != null && entity.Code.Equals("Administrator"))
{
return(true);
}
if (entity.UserName != null && entity.UserName.Equals("Administrator"))
{
return(true);
}
if (this.UserInfo == null)
{
return(false);
}
// 用户的默认角色是超级管理员
var roleManager = new PiRoleManager(this.DBProvider, this.UserInfo);
// 用户默认角色是否为超级管理员
PiRoleEntity roleEntity = null;
if (entity.RoleId != null)
{
// 用户在超级管理员群里
string[] roleIds = this.GetRoleIds(entity.Id);
foreach (string tmpid in roleIds)
{
if (tmpid.Equals(DefaultRole.Administrators.ToString()))
{
return(true);
}
roleEntity = roleManager.GetEntity(tmpid);
if (roleEntity.Code != null && roleEntity.Code.Equals(DefaultRole.Administrators.ToString()))
{
return(true);
}
}
}
return(false);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
/// 用户权限判断相关(需要实现对外调用)
//////////////////////////////////////////////////////////////////////////////////////////////////////
#region public bool IsInRole(UserInfo userInfo, string userId, string roleName) 指定用户是否在指定的角色里
/// <summary>
/// 指定用户是否在指定的角色里
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userId">用户主键</param>
/// <param name="roleName">角色名称</param>
/// <returns>指定用户是否在指定角色里，true：是，false：否</returns>
public bool IsInRole(UserInfo userInfo, string userId, string roleName)
{
var returnValue = false;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.PermissionService_IsInRole);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
// 先获得角色主键
string roleCode = new PiRoleManager(dbProvider, userInfo).GetProperty(PiRoleTable.FieldRealName, roleName, PiRoleTable.FieldCode);
// 判断用户的默认角色
if (!string.IsNullOrEmpty(roleCode))
{
returnValue = new PiUserRoleManager(dbProvider, userInfo).UserInRole(userId, roleCode);
}
});
return(returnValue);
}
/// <summary>
/// 按组织机构获取角色列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="organizeId">组织机构主键</param>
/// <param name="showUser">显示用户</param>
/// <returns>角色列表</returns>
public DataTable GetDTByOrganize(UserInfo userInfo, string organizeId, bool showUser = true)
{
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.RoleService_GetDTByOrganize);
var dtRole = new DataTable(PiRoleTable.TableName);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, (dbProvider) =>
{
// 获得角色列表
var manager = new PiRoleManager(dbProvider, userInfo);
dtRole = manager.GetDTByOrganize(organizeId);
PiUserManager userManager = new PiUserManager(dbProvider, userInfo);
if (showUser)
{
DataTable dataTableUser = userManager.GetDT();
if (!dtRole.Columns.Contains("Users"))
{
dtRole.Columns.Add("Users");
}
// 友善的显示属于多个角色的功能
string userName = string.Empty;
foreach (DataRow dr in dtRole.Rows)
{
userName = string.Empty;
// 获取所在用户
string[] userIds = userManager.GetUserIdsInRole(dr[PiRoleTable.FieldId].ToString());
if (userIds != null)
{
userName = userIds.Aggregate(userName, (current, t) => current + BusinessLogic.GetProperty(dataTableUser, t, PiRoleTable.FieldRealName) + ", ");
}
if (!string.IsNullOrEmpty(userName))
{
userName = userName.Substring(0, userName.Length - 2);
// 设置用户的名称
dr["Users"] = userName;
}
}
dtRole.AcceptChanges();
}
dtRole.TableName = PiRoleTable.TableName;
});
return(dtRole);
}
public bool UserInRole(string userId, string roleCode)
{
var returnValue = false;
if (string.IsNullOrEmpty(roleCode))
{
return(false);
}
var roleManager = new PiRoleManager(this.DBProvider, this.UserInfo);
var roleId = roleManager.GetId(PiRoleTable.FieldDeleteMark, 0, PiRoleTable.FieldCode, roleCode);
if (string.IsNullOrEmpty(roleId))
{
return(false);
}
var roleIds = GetAllRoleIds(userId);
returnValue = BusinessLogic.Exists(roleIds, roleId);
return(returnValue);
}
/// <summary>
/// 用户是否在某个角色中
/// </summary>
/// <param name="userId">用户主键</param>
/// <param name="realName">角色</param>
/// <returns>存在</returns>
public bool IsInRole(string userId, string realName)
{
var returnValue = false;
if (string.IsNullOrEmpty(realName))
{
return(false);
}
var roleManager = new PiRoleManager(this.DBProvider, this.UserInfo);
var roleId = roleManager.GetId(PiRoleTable.FieldDeleteMark, 0, PiRoleTable.FieldRealName, realName);
if (string.IsNullOrEmpty(roleId))
{
return(false);
}
var roleIds = GetAllRoleIds(userId);
returnValue = StringHelper.Exists(roleIds, roleId);
return(returnValue);
}
public UserInfo ConvertToUserInfo(UserInfo userInfo, PiUserEntity userEntity, PiUserLogOnEntity userLogOnEntity = null)
{
userInfo.Id = userEntity.Id;
userInfo.Code = userEntity.Code;
userInfo.UserName = userEntity.UserName;
userInfo.RealName = userEntity.RealName;
userInfo.CompanyId = userEntity.CompanyId;
userInfo.CompanyName = userEntity.CompanyName;
userInfo.DepartmentId = userEntity.DepartmentId;
userInfo.DepartmentName = userEntity.DepartmentName;
userInfo.WorkgroupId = userEntity.WorkgroupId;
userInfo.WorkgroupName = userEntity.WorkgroupName;
if (userLogOnEntity != null)
{
userInfo.OpenId = userLogOnEntity.OpenId;
}
if (userEntity.SecurityLevel == null)
{
userEntity.SecurityLevel = 0;
}
else
{
userInfo.SecurityLevel = (int)userEntity.SecurityLevel;
}
if (!string.IsNullOrEmpty(userEntity.RoleId))
{
// 获取角色名称
var roleManager = new PiRoleManager(DBProvider, UserInfo);
PiRoleEntity roleEntity = roleManager.GetEntity(userEntity.RoleId);
if (!string.IsNullOrEmpty(roleEntity.Id))
{
userInfo.RoleName = roleEntity.RealName;
userInfo.RoleId = roleEntity.Id;
}
}
return(userInfo);
}
/// <summary>
/// 添加用户
/// </summary>
/// <param name="dbProvider">数据库连接</param>
/// <param name="userInfo">用户信息</param>
/// <param name="userEntity">用户实体</param>
/// <param name="statusCode">状态码</param>
/// <param name="statusMessage">状态信息</param>
/// <returns>主键</returns>
public string AddUser(IDbProvider dbProvider, UserInfo userInfo, PiUserEntity userEntity, out string statusCode, out string statusMessage)
{
string returnValue = string.Empty;
var userManager = new PiUserManager(dbProvider, userInfo);
returnValue = userManager.Add(userEntity, out statusCode);
statusMessage = userManager.GetStateMessage(statusCode);
LogManager.Instance.Add(dbProvider, userInfo, this.serviceName, RDIFrameworkMessage.UserService_AddUser, MethodBase.GetCurrentMethod());
// 自己不用给自己发提示信息，这个提示信息是为了提高工作效率的，还是需要审核通过的，否则垃圾信息太多了
if (userEntity.Enabled == 0 && statusCode.Equals(StatusCode.OKAdd.ToString()))
{
// 不是系统管理员添加
if (!userInfo.IsAdministrator)
{
// 给超级管理员群组发信息
var roleManager = new PiRoleManager(dbProvider, userInfo);
string[] roleIds = roleManager.GetIds(PiRoleTable.FieldCode, "Administrators", PiRoleTable.FieldId);
string[] userIds = userManager.GetIds(PiUserTable.FieldCode, "Administrator", PiUserTable.FieldId);
// 发送请求审核的信息
var messageEntity = new CiMessageEntity
{
Id = BusinessLogic.NewGuid(),
FunctionCode = MessageFunction.WaitForAudit.ToString(),
ReceiverId = DefaultRole.Administrator.ToString(),
MSGContent = userInfo.RealName + "(" + userInfo.IPAddress + ")" + RDIFrameworkMessage.UserService_Application + userEntity.RealName + RDIFrameworkMessage.UserService_Check,
IsNew = 1,
ReadCount = 0,
Enabled = 1,
DeleteMark = 0
};
var messageManager = new CiMessageManager(dbProvider, userInfo);
messageManager.BatchSend(userIds, null, roleIds, messageEntity, false);
}
}
return(returnValue);
}
/// <summary>
/// 获取业务角色列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>业务角色列表</returns>
public DataTable GetApplicationRole(UserInfo userInfo)
{
var parameter = ParameterUtil.CreateWithMessage(userInfo
, MethodBase.GetCurrentMethod()
, this.serviceName
, RDIFrameworkMessage.RoleService_GetDT);
var dt = new DataTable(PiRoleTable.TableName);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, (dbProvider) =>
{
// 获得角色列表
var manager = new PiRoleManager(dbProvider, userInfo, PiRoleTable.TableName);
var parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(PiRoleTable.FieldCategory, "ApplicationRole"),
new KeyValuePair <string, object>(PiRoleTable.FieldDeleteMark, 0)
};
dt = manager.GetDT(parameters, PiRoleTable.FieldSortCode);
dt.TableName = PiRoleTable.TableName;
});
return(dt);
}
/// <summary>
/// 获取角色分页列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="recordCount">所有角色数</param>
/// <param name="pageIndex">当前页</param>
/// <param name="pageSize">分页大小（默认20条）</param>
/// <param name="whereConditional">条件表达式</param>
/// <param name="order">排序字段</param>
/// <returns>数据表</returns>
public DataTable GetDTByPage(UserInfo userInfo, out int recordCount, int pageIndex = 1, int pageSize = 20, string whereConditional = "", string order = "")
{
var dataTable = new DataTable(PiRoleTable.TableName);
var returnRecordCount = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.RoleService_GetDT);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var manager = new PiRoleManager(dbProvider, userInfo);
if (string.IsNullOrEmpty(whereConditional))
{
whereConditional = PiRoleTable.FieldDeleteMark + " = 0 ";
}
else
{
whereConditional += " AND " + PiRoleTable.FieldDeleteMark + " = 0 ";
}
dataTable = manager.GetDTByPage(out returnRecordCount, pageIndex, pageSize, whereConditional, order);
dataTable.TableName = PiRoleTable.TableName;
});
recordCount = returnRecordCount;
return(dataTable);
}
