/// <summary>
/// 获取有岗位的组织机构主键
/// </summary>
/// <param name="userId">用户主键</param>
/// <param name="dutyName">岗位名称</param>
/// <returns>主键数组</returns>
public string[] GetOrganizeIdsByDutyName(string userId = null, string dutyName = "部门主管")
{
// 这里需要一个转换的过程，先找到系统角色里这个角色是什么编号
string dutyCode = "Manager";
BaseRoleManager roleManager = new BaseRoleManager(this.UserInfo);
List<KeyValuePair<string, object>> parameters = new List<KeyValuePair<string, object>>();
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldRealName, dutyName));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldCategoryCode, "SystemRole"));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldEnabled, 1));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldDeletionStateCode, 0));
roleManager.GetId(parameters);
// 这里需要返回公司的主键数组
return GetOrganizeIdsByDuty(userId, dutyCode);
}
/// <summary>
/// 按某个权限获取角色 主键数组
/// </summary>
/// <param name="managerUserId">管理用户主键</param>
/// <param name="permissionItemCode">权限编号</param>
/// <returns>主键数组</returns>
public string[] GetRoleIds(string managerUserId, string permissionItemCode)
{
string sqlQuery = this.GetRoleIdsSql(managerUserId, permissionItemCode);
DataTable dataTable = DbHelper.Fill(sqlQuery);
string[] ids = BaseBusinessLogic.FieldToArray(dataTable, BaseBusinessLogic.FieldId);
// 这里列出只是有效地，没被删除的角色主键
if (ids != null && ids.Length > 0)
{
BaseRoleManager roleManager = new BaseRoleManager(this.DbHelper, this.UserInfo);
List<KeyValuePair<string, object>> parameters = new List<KeyValuePair<string, object>>();
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldId, ids));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldEnabled, 1));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldDeletionStateCode, 0));
ids = roleManager.GetIds(parameters);
}
return ids;
}
/// <summary>
/// 按某个权限获取角色 数据表
/// </summary>
/// <param name="userId">管理用户主键</param>
/// <param name="permissionItemCode">权限编号</param>
/// <returns>数据表</returns>
public DataTable GetRoleDT(string userId, string permissionItemCode)
{
DataTable returnValue = new DataTable(BaseRoleEntity.TableName);
//string[] names = null;
//object[] values = null;
// 这里需要判断,是系统权限？
bool isRole = false;
BaseUserManager userManager = new BaseUserManager(this.DbHelper, this.UserInfo);
// 用户管理员,这里需要判断,是业务权限？
isRole = userManager.IsInRoleByCode(userId, "UserAdmin") || userManager.IsInRoleByCode(userId, "Admin");
if (isRole)
{
BaseRoleManager manager = new BaseRoleManager(this.DbHelper, this.UserInfo);
List<KeyValuePair<string, object>> parameters = new List<KeyValuePair<string, object>>();
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldIsVisible, 1));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldEnabled, 1));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldDeletionStateCode, 0));
returnValue = manager.GetDataTable(parameters, BaseModuleEntity.FieldSortCode);
returnValue.TableName = this.CurrentTableName;
return returnValue;
}
string sqlQuery = string.Empty;
sqlQuery = " SELECT * "
+ " FROM " + BaseRoleEntity.TableName
+ " WHERE " + BaseRoleEntity.FieldCreateUserId + " = '" + this.UserInfo.Id + "'"
+ " OR " + BaseRoleEntity.TableName + "." + BaseRoleEntity.FieldId + " IN ("
+ this.GetRoleIdsSql(userId, permissionItemCode)
+ " ) AND (" + BaseRoleEntity.FieldDeletionStateCode + " = 0) "
+ " AND (" + BaseRoleEntity.FieldIsVisible + " = 1) "
+ " ORDER BY " + BaseRoleEntity.FieldSortCode;
return DbHelper.Fill(sqlQuery);
}
/// <summary>
/// 用户是否在某个角色中
/// </summary>
/// <param name="userId">用户主键</param>
/// <param name="roleCode">角色编号</param>
/// <returns>存在</returns>
public bool IsInRoleByCode(string userId, string code)
{
bool returnValue = false;
if (string.IsNullOrEmpty(code))
{
return false;
}
string tableName = BaseRoleEntity.TableName;
if (!string.IsNullOrEmpty(BaseSystemInfo.SystemCode))
{
tableName = BaseSystemInfo.SystemCode + "Role";
}
BaseRoleManager roleManager = new BaseRoleManager(this.DbHelper, this.UserInfo, tableName);
string roleId = roleManager.GetId(
new KeyValuePair<string, object>(BaseRoleEntity.FieldDeletionStateCode, 0)
, new KeyValuePair<string, object>(BaseRoleEntity.FieldCode, code));
if (string.IsNullOrEmpty(roleId))
{
return false;
}
string[] roleIds = GetAllRoleIds(userId);
returnValue = StringUtil.Exists(roleIds, roleId);
return returnValue;
}
/// <summary>
/// 用户添加到角色
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="roleName">角色名</param>
/// <param name="permissionItemCode">权限编号</param>
/// <returns>主键</returns>
public string AddUserToRole(BaseUserInfo userInfo, string userName, string roleName)
{
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
string returnValue = string.Empty;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
string userId = userManager.GetId(new KeyValuePair<string, object>(BaseUserEntity.FieldUserName, userName));
BaseRoleManager roleManager = new BaseRoleManager(dbHelper, userInfo);
string roleId = roleManager.GetId(new KeyValuePair<string, object>(BaseRoleEntity.FieldRealName, roleName));
if (!String.IsNullOrEmpty(userId) && !String.IsNullOrEmpty(roleId))
{
returnValue = userManager.AddToRole(userId, roleId);
}
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}
}
return returnValue;
}
/// <summary>
/// 批量打角色删除标志
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <returns>影响行数</returns>
public int SetDeleted(BaseUserInfo userInfo, string[] ids)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
int returnValue = 0;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
string tableName = BaseRoleEntity.TableName;
if (!string.IsNullOrEmpty(BaseSystemInfo.SystemCode))
{
tableName = BaseSystemInfo.SystemCode + "Role";
}
BaseRoleManager roleManager = new BaseRoleManager(dbHelper, userInfo, tableName);
switch (DbHelper.DbType)
{
case DbTypes.Access:
// 考虑主键是数值类型的，支持Access//xtzwd
int[] keys = BaseBusinessLogic.GetIntKeys(ids);
returnValue = roleManager.SetDeleted(keys, true);
break;
default:
returnValue = roleManager.SetDeleted(ids, true);
break;
}
BaseLogManager.Instance.Add(dbHelper, userInfo, serviceName, AppMessage.RoleService_SetDeleted, MethodBase.GetCurrentMethod());
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}
}
// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return returnValue;
}
/// <summary>
/// 获取用户群组列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public DataTable GetUserGroup(BaseUserInfo userInfo)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
BaseSystemInfo.IsAuthorized(userInfo);
#endif
DataTable dataTable = new DataTable(BaseRoleEntity.TableName);
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
string tableName = BaseRoleEntity.TableName;
if (!string.IsNullOrEmpty(BaseSystemInfo.SystemCode))
{
tableName = BaseSystemInfo.SystemCode + "Role";
}
// 获得角色列表
BaseRoleManager roleManager = new BaseRoleManager(dbHelper, userInfo, tableName);
List<KeyValuePair<string, object>> parameters = new List<KeyValuePair<string, object>>();
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldCategoryCode, "UserGroup"));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldDeletionStateCode, 0));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldIsVisible, 1));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldCreateUserId, userInfo.Id));
dataTable = roleManager.GetDataTable(parameters, BaseRoleEntity.FieldSortCode);
dataTable.TableName = tableName;
BaseLogManager.Instance.Add(dbHelper, userInfo, serviceName, AppMessage.RoleService_GetDataTable, 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="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <param name="targetId">目标主键</param>
/// <returns>影响行数</returns>
public int BatchMoveTo(BaseUserInfo userInfo, string[] ids, string targetId)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
int returnValue = 0;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
string tableName = BaseRoleEntity.TableName;
if (!string.IsNullOrEmpty(BaseSystemInfo.SystemCode))
{
tableName = BaseSystemInfo.SystemCode + "Role";
}
BaseRoleManager roleManager = new BaseRoleManager(dbHelper, userInfo, tableName);
returnValue = roleManager.BatchMoveTo(ids, targetId);
BaseLogManager.Instance.Add(dbHelper, userInfo, serviceName, AppMessage.RoleService_BatchMoveTo, MethodBase.GetCurrentMethod());
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}
}
// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return returnValue;
}
/// <summary>
/// 用户是否在指定的角色里
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="UserId">用户主键</param>
/// <param name="roleName">角色名称</param>
/// <returns>在角色里</returns>
public bool IsInRole(BaseUserInfo userInfo, string userId, string roleName)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
bool returnValue = false;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
// 先获得角色主键
BaseRoleManager roleManager = new BaseRoleManager(dbHelper, userInfo);
string roleCode = roleManager.GetProperty(new KeyValuePair<string, object>(BaseRoleEntity.FieldRealName, roleName), BaseRoleEntity.FieldCode);
// 判断用户的默认角色
if (!string.IsNullOrEmpty(roleCode))
{
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
returnValue = userManager.IsInRoleByCode(userId, roleCode);
}
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.PermissionService_IsInRole, MethodBase.GetCurrentMethod());
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}
}
// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return returnValue;
}
private string GetRoleId(Button btnRole)
{
string returnValue = string.Empty;
BaseRoleManager roleManager = new BaseRoleManager(this.UserInfo);
List<KeyValuePair<string, object>> parameters = new List<KeyValuePair<string, object>>();
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldOrganizeId, this.EntityId));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldCategoryCode, "Duty"));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldCode, btnRole.Name.Substring(3).Replace("Delete","")));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldEnabled, 1));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldDeletionStateCode, 0));
returnValue = roleManager.GetProperty(parameters, BaseRoleEntity.FieldId);
btnRole.Tag = returnValue;
return returnValue;
}
private void btnRole_Click(object sender, EventArgs e)
{
string txtButton = ((Button)sender).Text;
Button btnRole = (Button)sender;
string roldId = GetRoleId(btnRole);
if (string.IsNullOrEmpty(roldId))
{
BaseRoleEntity roleEntity = new BaseRoleEntity();
roleEntity.OrganizeId = this.EntityId;
roleEntity.Code = ((Button)sender).Name.Substring(3).Replace("Delete", "");
roleEntity.RealName = this.txtFullName.Text + "_" + txtButton;
roleEntity.Description = ((Button)sender).Text;
roleEntity.CategoryCode = "Duty";
roleEntity.Enabled = 1;
roleEntity.DeletionStateCode = 0;
BaseRoleManager roleManager = new BaseRoleManager(this.UserInfo);
roldId = roleManager.Add(roleEntity);
btnRole.Tag = roldId;
}
FrmRoleUserAdmin frmRoleUserAdmin = new FrmRoleUserAdmin(roldId);
frmRoleUserAdmin.ShowDialog(this);
this.GetRoleUser(btnRole);
}
/// <summary>
/// 获取用户的角色列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public DataTable GetRoleDT(BaseUserInfo userInfo)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
BaseSystemInfo.IsAuthorized(userInfo);
#endif
DataTable dataTable = new DataTable(BaseRoleEntity.TableName);
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
List<KeyValuePair<string, object>> parameters = new List<KeyValuePair<string, object>>();
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldEnabled, 1));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldDeletionStateCode, 0));
BaseRoleManager roleManager = new BaseRoleManager(dbHelper, userInfo);
// 获取有效的，未必删除的数据，按排序码排序
dataTable = roleManager.GetDataTable(parameters, BaseRoleEntity.FieldSortCode);
// 不是超级管理员，不能添加超级管理员
if (!userInfo.IsAdministrator)
{
foreach (DataRow dataRow in dataTable.Rows)
{
if (dataRow[BaseRoleEntity.FieldCode].ToString().Equals(DefaultRole.Administrators.ToString()))
{
dataRow.Delete();
}
}
dataTable.AcceptChanges();
}
dataTable.TableName = BaseUserEntity.TableName;
dataTable.DefaultView.Sort = BaseUserEntity.FieldSortCode;
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.UserService_GetRoleDT, 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="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="userInfo">用户</param>
/// <param name="roleName">角色名</param>
/// <param name="permissionItemCode">权限编号</param>
/// <returns>主键</returns>
public int RevokeRolePermission(BaseUserInfo userInfo, string roleName, string permissionItemCode)
{
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
int returnValue = 0;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseRoleManager roleManager = new BaseRoleManager(dbHelper, userInfo);
string roleId = roleManager.GetId(new KeyValuePair<string, object>(BaseRoleEntity.FieldRealName, roleName));
BasePermissionItemManager permissionItemManager = new BasePermissionItemManager(dbHelper, userInfo);
string permissionItemId = permissionItemManager.GetId(new KeyValuePair<string, object>(BasePermissionItemEntity.FieldCode, permissionItemCode));
if (!String.IsNullOrEmpty(roleId) && !String.IsNullOrEmpty(permissionItemId))
{
BaseRolePermissionManager rolePermissionManager = new BaseRolePermissionManager(dbHelper, userInfo);
returnValue = rolePermissionManager.Revoke(roleId, permissionItemId);
}
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}
}
return returnValue;
}
/// <summary>
/// 删除角色
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="role">角色</param>
/// <returns>影响行数</returns>
public int DeleteRole(BaseUserInfo userInfo, string role)
{
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
int returnValue = 0;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseRoleManager roleManager = new BaseRoleManager(dbHelper, userInfo);
string id = roleManager.GetId(new KeyValuePair<string, object>(BaseRoleEntity.FieldRealName, role));
if (!String.IsNullOrEmpty(id))
{
// 在删除时，可能会把相关的其他配置角色会删除掉，所以需要调用这个方法。
returnValue = roleManager.Delete(id);
}
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}
}
return returnValue;
}
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;
}
/// <summary>
/// 下个流程发送给谁
/// </summary>
/// <param name="id">当前主键</param>
/// <returns>影响行数</returns>
private int StepAuditTransmit(string currentId, string workFlowCategory, string sendToId, string auditIdea)
{
BaseWorkFlowCurrentEntity workFlowCurrentEntity = this.GetEntity(currentId);
// 1.记录当前的审核时间、审核人信息
workFlowCurrentEntity.ToDepartmentId = this.UserInfo.DepartmentId;
workFlowCurrentEntity.ToDepartmentName = this.UserInfo.DepartmentName;
workFlowCurrentEntity.ToUserId = this.UserInfo.Id;
workFlowCurrentEntity.ToUserRealName = this.UserInfo.RealName;
workFlowCurrentEntity.AuditStatus = AuditStatus.Transmit.ToString();
workFlowCurrentEntity.AuditStatusName = AuditStatus.Transmit.ToDescription();
// 2.记录审核日志
this.AddHistory(workFlowCurrentEntity);
// 3.上一个审核结束了，新的审核又开始了，更新待审核情况
workFlowCurrentEntity.AuditUserId = this.UserInfo.Id;
workFlowCurrentEntity.AuditUserRealName = this.UserInfo.RealName;
workFlowCurrentEntity.AuditDate = DateTime.Now;
workFlowCurrentEntity.AuditIdea = auditIdea;
// 是否提交给部门审批
if (workFlowCategory.Equals("ByOrganize"))
{
BaseOrganizeManager organizeManager = new BaseOrganizeManager(UserInfo);
BaseOrganizeEntity organizeEntity = organizeManager.GetEntity(sendToId);
// 设置审批部门主键
workFlowCurrentEntity.ToDepartmentId = sendToId;
// 设置审批部门名称
workFlowCurrentEntity.ToDepartmentName = organizeEntity.FullName;
}
// 是否提交给角色审批
if (workFlowCategory.Equals("ByRole"))
{
BaseRoleManager roleManger = new BaseRoleManager(this.UserInfo);
BaseRoleEntity roleEntity = roleManger.GetEntity(sendToId);
// 设置审批角色主键
workFlowCurrentEntity.ToRoleId = sendToId;
// 设置审批角色名称
workFlowCurrentEntity.ToRoleRealName = roleEntity.RealName;
}
// 是否提交给用户审批
if (workFlowCategory.Equals("ByUser"))
{
BaseUserManager userManager = new BaseUserManager(UserInfo);
BaseUserEntity userEntity = userManager.GetEntity(sendToId);
// 设置审批用户主键
workFlowCurrentEntity.ToUserId = sendToId;
// 设置审批用户名称
workFlowCurrentEntity.ToUserRealName = userEntity.RealName;
// TODO 用户的部门信息需要处理
if (!string.IsNullOrEmpty(userEntity.DepartmentId))
{
BaseOrganizeManager organizeManager = new BaseOrganizeManager(UserInfo);
BaseOrganizeEntity organizeEntity = organizeManager.GetEntity(userEntity.DepartmentId);
workFlowCurrentEntity.ToDepartmentId = userEntity.DepartmentId;
workFlowCurrentEntity.ToDepartmentName = organizeEntity.FullName;
}
}
workFlowCurrentEntity.AuditStatus = AuditStatus.WaitForAudit.ToString();
workFlowCurrentEntity.AuditStatusName = AuditStatus.WaitForAudit.ToDescription();
// 当前审核人的信息写入当前工作流
workFlowCurrentEntity.Enabled = 0;
workFlowCurrentEntity.DeletionStateCode = 0;
return this.UpdateEntity(workFlowCurrentEntity);
}
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="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>
/// 发送联络单
/// </summary>
/// <param name="receiverIds">接收者</param>
/// <param name="organizeIds">组织机构数组</param>
/// <param name="roleIds">角色数组</param>
/// <returns>影响行数</returns>
public int Send(string contactId, string[] receiverIds, string[] organizeIds, string[] roleIds)
{
BaseUserManager userManager = new BaseUserManager(DbHelper, UserInfo);
receiverIds = userManager.GetUserIds(receiverIds, organizeIds, roleIds);
// 删除邮件的处理技巧、发送给部门的、发送给角色的。
// 删除邮件的列表过滤问题解决
BaseContactDetailsManager contactDetailsManager = new BaseContactDetailsManager(DbHelper, UserInfo);
BaseContactDetailsEntity contactDetailsEntity = null;
// 组织机构数组
if (organizeIds != null)
{
BaseOrganizeManager organizeManager = new BaseOrganizeManager(DbHelper, UserInfo);
for (int i = 0; i < organizeIds.Length; i++)
{
contactDetailsEntity = new BaseContactDetailsEntity();
// 这里一定要给个不可猜测的主键，为了提高安全性
contactDetailsEntity.Id = BaseBusinessLogic.NewGuid();
contactDetailsEntity.ContactId = contactId;
contactDetailsEntity.Category = "Organize";
contactDetailsEntity.ReceiverId = organizeIds[i];
contactDetailsEntity.ReceiverRealName = organizeManager.GetProperty(organizeIds[i], BaseOrganizeEntity.FieldFullName);
contactDetailsEntity.IsNew = 1;
contactDetailsEntity.Enabled = 1;
contactDetailsEntity.NewComment = 0;
contactDetailsManager.Add(contactDetailsEntity, false);
}
}
// 角色数组
if (roleIds != null)
{
BaseRoleManager roleManager = new BaseRoleManager(DbHelper, UserInfo);
for (int i = 0; i < roleIds.Length; i++)
{
contactDetailsEntity = new BaseContactDetailsEntity();
// 这里一定要给个不可猜测的主键，为了提高安全性
contactDetailsEntity.Id = BaseBusinessLogic.NewGuid();
contactDetailsEntity.ContactId = contactId;
contactDetailsEntity.Category = "Role";
contactDetailsEntity.ReceiverId = roleIds[i];
contactDetailsEntity.ReceiverRealName = roleManager.GetProperty(roleIds[i], BaseRoleEntity.FieldRealName);
contactDetailsEntity.IsNew = 1;
contactDetailsEntity.Enabled = 1;
contactDetailsEntity.NewComment = 0;
contactDetailsManager.Add(contactDetailsEntity, false);
}
}
return this.Send(contactId, receiverIds);
}
/// <summary>
/// 查询角色列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="organizeId">组织机构主键</param>
/// <param name="search">查询字符串</param>
/// <returns>数据表</returns>
public DataTable Search(BaseUserInfo userInfo, string organizeId, string searchValue)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
DataTable dataTable = new DataTable(BaseRoleEntity.TableName);
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
string tableName = BaseRoleEntity.TableName;
if (!string.IsNullOrEmpty(BaseSystemInfo.SystemCode))
{
tableName = BaseSystemInfo.SystemCode + "Role";
}
// 获得角色列表
BaseRoleManager roleManager = new BaseRoleManager(dbHelper, userInfo, tableName);
dataTable = roleManager.Search(organizeId, searchValue);
dataTable.TableName = BaseRoleEntity.TableName;
BaseLogManager.Instance.Add(dbHelper, userInfo, serviceName, AppMessage.RoleService_Search, 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="userId">用户主键</param>
/// <param name="realName">角色</param>
/// <returns>存在</returns>
public bool IsInRole(string userId, string realName)
{
bool returnValue = false;
if (string.IsNullOrEmpty(realName))
{
return false;
}
BaseRoleManager roleManager = new BaseRoleManager(this.DbHelper, this.UserInfo);
string roleId = roleManager.GetId(new KeyValuePair<string, object>(BaseRoleEntity.FieldDeletionStateCode, 0)
, new KeyValuePair<string, object>(BaseRoleEntity.FieldRealName, realName));
if (string.IsNullOrEmpty(roleId))
{
return false;
}
string[] roleIds = GetAllRoleIds(userId);
returnValue = StringUtil.Exists(roleIds, roleId);
return returnValue;
}
/// <summary>
/// 添加用户
/// </summary>
/// <param name="dbHelper">数据库连接</param>
/// <param name="userInfo">用户信息</param>
/// <param name="userEntity">用户实体</param>
/// <param name="statusCode">状态码</param>
/// <param name="statusMessage">状态信息</param>
/// <returns>主键</returns>
public string AddUser(IDbHelper dbHelper, BaseUserInfo userInfo, BaseUserEntity userEntity, out string statusCode, out string statusMessage)
{
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
BaseSystemInfo.IsAuthorized(userInfo);
#endif
string returnValue = string.Empty;
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
// 若是系统需要用加密的密码，这里需要加密密码。
if (BaseSystemInfo.ServerEncryptPassword)
{
userEntity.UserPassword = userManager.EncryptUserPassword(userEntity.UserPassword);
// 安全通讯密码、交易密码也生成好
userEntity.CommunicationPassword = userManager.EncryptUserPassword(userEntity.CommunicationPassword);
}
returnValue = userManager.Add(userEntity, out statusCode);
statusMessage = userManager.GetStateMessage(statusCode);
// 自己不用给自己发提示信息，这个提示信息是为了提高工作效率的，还是需要审核通过的，否则垃圾信息太多了
if (userEntity.Enabled == 0 && statusCode.Equals(StatusCode.OKAdd.ToString()))
{
// 不是系统管理员添加
if (!userInfo.IsAdministrator)
{
// 给超级管理员群组发信息
BaseRoleManager roleManager = new BaseRoleManager(dbHelper, userInfo);
string[] roleIds = roleManager.GetIds(new KeyValuePair<string, object>(BaseRoleEntity.FieldCode, "Administrators"));
string[] userIds = userManager.GetIds(new KeyValuePair<string, object>(BaseUserEntity.FieldCode, "Administrator"));
// 发送请求审核的信息
BaseMessageEntity messageEntity = new BaseMessageEntity();
messageEntity.FunctionCode = MessageFunction.WaitForAudit.ToString();
// Pcsky 2012.05.04 显示申请的用户名
messageEntity.Contents = userInfo.RealName + "(" + userInfo.IPAddress + ")" + AppMessage.UserService_Application + userEntity.UserName + AppMessage.UserService_Check;
//messageEntity.Contents = userInfo.RealName + "(" + userInfo.IPAddress + ")" + AppMessage.UserService_Application + userEntity.RealName + AppMessage.UserService_Check;
BaseMessageManager messageManager = new BaseMessageManager(dbHelper, userInfo);
messageManager.BatchSend(userIds, null, roleIds, messageEntity, false);
}
}
return returnValue;
}
/// <summary>
/// 按某个权限域获取角色列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userId">用户主键</param>
/// <param name="permissionItemCode">数据权限编号</param>
/// <returns>数据表</returns>
public DataTable GetRoleDTByPermissionScope(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(BaseRoleEntity.TableName);
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
// 若权限是空的，直接返回所有数据
if (userInfo.IsAdministrator || String.IsNullOrEmpty(permissionItemCode))
{
// 获得角色列表
BaseRoleManager roleManager = new BaseRoleManager(dbHelper, userInfo);
List<KeyValuePair<string, object>> parameters = new List<KeyValuePair<string, object>>();
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldIsVisible, 1));
parameters.Add(new KeyValuePair<string, object>(BaseRoleEntity.FieldDeletionStateCode, 0));
dataTable = roleManager.GetDataTable(parameters, BaseRoleEntity.FieldSortCode);
}
else
{
// 获得组织机构列表
BasePermissionScopeManager permissionScopeManager = new BasePermissionScopeManager(dbHelper, userInfo);
dataTable = permissionScopeManager.GetRoleDT(userInfo.Id, permissionItemCode);
}
dataTable.TableName = BaseRoleEntity.TableName;
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.PermissionService_GetRoleDTByPermission, 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;
}
