/// <summary>
/// 批量打删除标志
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <returns>影响行数</returns>
public int SetDeleted(UserInfo userInfo, string[] ids)
{
int returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.StaffService_SetDeleted);
ServiceUtil.ProcessRDIWriteDbWithTran(userInfo, parameter, dbProvider =>
{
var userManager = new PiUserManager(dbProvider, userInfo);
var staffManager = new PiStaffManager(dbProvider, userInfo);
PiStaffEntity staffEntity = null;
for (int i = 0; i < ids.Length; i++)
{
// 删除相应的用户
staffEntity = staffManager.GetEntity(ids[i]);
if (staffEntity.UserId != null)
{
userManager.SetDeleted(staffEntity.UserId);
}
// 删除职员
returnValue += staffManager.SetDeleted(ids[i], true);
var staffOrganizeManager = new PiStaffOrganizeManager(dbProvider, userInfo);
returnValue += staffOrganizeManager.SetDeleted(new string[] { PiStaffOrganizeTable.FieldStaffId }, new string[] { ids[i] });
}
});
return(returnValue);
}
/// <summary>
/// 批量发送消息
/// </summary>
/// <param name="receiverIds">接收者主键组</param>
/// <param name="organizeIds">组织机构主键组</param>
/// <param name="roleIds">角色主键组</param>
/// <param name="messageEntity">实体</param>
/// <returns>影响行数</returns>
public int BatchSend(string[] receiverIds, string[] organizeIds, string[] roleIds, CiMessageEntity messageEntity, bool saveSend = true)
{
PiUserManager userManager = new PiUserManager(DBProvider, UserInfo);
receiverIds = userManager.GetUserIds(receiverIds, organizeIds, roleIds);
return(this.Send(messageEntity, receiverIds, saveSend));
}
public bool ArchRelation(string userId, string workFlowId, string workTaskId, string workFlowInstanceId, string workTaskInstanceId, OperParameter operParam)
{
switch (operParam.OperRelation)
{
case 1: //本部门领导
var orgEntity = new PiOrganizeManager(DbFactoryProvider.GetProvider(SystemInfo.RDIFrameworkDbType, SystemInfo.RDIFrameworkDbConectionString)).GetEntity(operParam.OperContent);
var uEntity = new PiUserManager(DbFactoryProvider.GetProvider(SystemInfo.RDIFrameworkDbType, SystemInfo.RDIFrameworkDbConectionString)).GetEntity(orgEntity.ManagerId);
operParam.OperContent = uEntity.Id;
operParam.OperContenText = uEntity.UserName;
AssignUser(userId, workFlowId, workTaskId, workFlowInstanceId, workTaskInstanceId, operParam);
break;
case 2: //无此情况
break;
case 3: //上级部门,一个部门只有一个上级部门
//ToDo...
break;
case 4: //下级部门
//ToDo...
break;
case 5: //上级部门领导
//ToDo...
break;
case 6: //下级部门领导
//ToDo...
break;
}
return(true);
}
/// <summary>
/// 广播消息
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="message">消息内容</param>
/// <returns>主键</returns>
public int Broadcast(UserInfo userInfo, string message)
{
int returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, "广播消息");
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
string[] receiverIds = null;
var userManager = new PiUserManager(dbProvider, userInfo);
receiverIds = userManager.GetIds(new KeyValuePair <string, object>(PiUserTable.FieldEnabled, 1), new KeyValuePair <string, object>(PiUserTable.FieldDeleteMark, 0));
var messageManager = new CiMessageManager(dbProvider, userInfo);
var messageEntity = new CiMessageEntity
{
Id = BusinessLogic.NewGuid(),
FunctionCode = MessageFunction.Remind.ToString(),
MSGContent = message,
IsNew = 1,
ReadCount = 0,
Enabled = 1,
DeleteMark = 0
};
returnValue = messageManager.BatchSend(receiverIds, string.Empty, string.Empty, messageEntity, false);
});
return(returnValue);
}
/// <summary>
/// 按员工的修改信息，把用户信息进行修改
/// </summary>
/// <param name="staffId">员工主键</param>
/// <returns>影响行数</returns>
public int UpdateUser(string staffId)
{
DataTable dataTable = this.GetDT(PiStaffTable.FieldId, staffId);
PiStaffEntity staffEntity = BaseEntity.Create <PiStaffEntity>(dataTable); //new PiStaffEntity(dataTable);
if (!string.IsNullOrEmpty(staffEntity.UserId))
{
// 员工信息改变时，用户信息也跟着改变。
PiUserManager userManager = new PiUserManager(DBProvider, UserInfo);
PiUserEntity userEntity = userManager.GetEntity(staffEntity.UserId.ToString());
// userEntity.Company = staffEntity.CompanyName;
// userEntity.Department = staffEntity.DepartmentName;
// userEntity.Workgroup = staffEntity.WorkgroupName;
userEntity.UserName = staffEntity.UserName;
userEntity.RealName = staffEntity.RealName;
userEntity.Code = staffEntity.Code;
userEntity.Email = staffEntity.Email;
userEntity.Enabled = int.Parse(staffEntity.Enabled.ToString());
// userEntity.Duty = staffEntity.DutyName;
// userEntity.Title = staffEntity.TitleName;
userEntity.Gender = staffEntity.Gender;
userEntity.Birthday = BusinessLogic.ConvertToNullableDateTime(staffEntity.Birthday);
userEntity.Mobile = staffEntity.Mobile;
}
return(0);
}
/// <summary>
/// 解锁指定用户
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userName">登录名（用户名）</param>
/// <returns>大于0解锁成功</returns>
public int UnLockUser(UserInfo userInfo, string userName)
{
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.LogOnService_UnLockUser);
int result = 0;
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var manager = new PiUserManager(userInfo);
var parameters = new List <KeyValuePair <string, object> > {
new KeyValuePair <string, object>(PiUserTable.FieldUserName, userName),
new KeyValuePair <string, object>(PiUserTable.FieldEnabled, 1),
new KeyValuePair <string, object>(PiUserTable.FieldDeleteMark, 0)
};
var entity = BaseEntity.Create <PiUserEntity>(manager.GetDT(parameters, 0, null));
if ((entity != null) && !string.IsNullOrEmpty(entity.Id))
{
var longOnmanager = new PiUserLogOnManager();
PiUserLogOnEntity lonOnentity = longOnmanager.GetEntity(entity.Id);
lonOnentity.LockStartDate = null;
lonOnentity.LockEndDate = null;
result = longOnmanager.Update(lonOnentity);
}
});
return(result);
}
/// <summary>
/// 用户离职
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userName">离职人员用户名</param>
/// <param name="dimissionCause">离职原因</param>
/// <param name="dimissionDate">离职日期</param>
/// <param name="dimissionWhither">离职去向</param>
/// <returns>大于0操作成功</returns>
public int UserDimission(UserInfo userInfo, string userName, string dimissionCause, DateTime?dimissionDate, string dimissionWhither = null)
{
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.LogOnService_UserDimission);
int result = 0;
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var manager = new PiUserManager(userInfo);
var parameters = new List <KeyValuePair <string, object> > {
new KeyValuePair <string, object>(PiUserTable.FieldUserName, userName),
new KeyValuePair <string, object>(PiUserTable.FieldEnabled, 1),
new KeyValuePair <string, object>(PiUserTable.FieldDeleteMark, 0)
};
var entity = BaseEntity.Create <PiUserEntity>(manager.GetDT(parameters, 0, null));
if ((entity != null) && !string.IsNullOrEmpty(entity.Id))
{
entity.Enabled = 0;
entity.IsDimission = 1;
entity.DimissionCause = dimissionCause;
entity.DimissionWhither = dimissionWhither;
entity.DimissionDate = dimissionDate ?? DateTime.Now;
result = manager.Update(entity);
//离职的员工就不能登录系统了，应该锁定了
var longOnmanager = new PiUserLogOnManager();
PiUserLogOnEntity lonOnentity = longOnmanager.GetEntity(entity.Id);
lonOnentity.LockStartDate = DateTime.Now;
result += longOnmanager.Update(lonOnentity);
}
});
return(result);
}
/// <summary>
/// 员工关联用户
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="staffId">员工主键</param>
/// <param name="userId">用户主键</param>
/// <returns>影响行数</returns>
public int SetStaffUser(UserInfo userInfo, string staffId, string userId)
{
int returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.StaffService_SetStaffUser, "员工主键：" + staffId + ",用户主键:" + userId);
ServiceUtil.ProcessRDIWriteDbWithTran(userInfo, parameter, dbProvider =>
{
var staffManager = new PiStaffManager(dbProvider, userInfo);
if (string.IsNullOrEmpty(userId))
{
returnValue = staffManager.SetProperty(staffId, PiStaffTable.FieldUserId, userId);
}
else
{
// 一个用户只能帮定到一个帐户上，检查是否已经绑定过这个用户了。
string[] staffIds = staffManager.GetIds(new KeyValuePair <string, object>(PiStaffTable.FieldUserId, userId), new KeyValuePair <string, object>(PiStaffTable.FieldDeleteMark, 0));
if (staffIds == null || staffIds.Length == 0)
{
returnValue = staffManager.SetProperty(staffId, PiStaffTable.FieldUserId, userId);
var userManager = new PiUserManager(dbProvider, userInfo);
var userEntity = userManager.GetEntity(userId);
returnValue = staffManager.SetProperty(staffId, PiStaffTable.FieldUserName, userEntity.UserName);
}
}
});
return(returnValue);
}
/// <summary>
/// 删除
/// </summary>
/// <param name="id">主键</param>
/// <returns>影响行数</returns>
public int Delete(string id)
{
int returnValue = 0;
PiStaffEntity staffEntity = this.GetEntity(id);
if (!string.IsNullOrEmpty(staffEntity.UserId))
{
// 删除角色用户关联表
returnValue += DbCommonLibary.Delete(DBProvider, PiUserRoleTable.TableName, PiUserRoleTable.FieldUserId, staffEntity.UserId);
// 删除用户的权限数据
// 删除用户的权限范围数据
// 删除相关的用户数据
PiUserManager userManager = new PiUserManager(DBProvider, UserInfo);
returnValue += userManager.DeleteEntity(staffEntity.UserId);
}
//删除员工组织关系关联表
returnValue += DbCommonLibary.Delete(DBProvider, PiStaffOrganizeTable.TableName, PiStaffOrganizeTable.FieldStaffId, id);
// 删除员工本表
returnValue += DbCommonLibary.Delete(DBProvider, PiStaffTable.TableName, PiStaffTable.FieldId, id);
return(returnValue);
}
/// <summary>
/// 按组织机构获取用户列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="organizeId">组织机构主键</param>
/// <returns>数据表</returns>
public DataTable GetUserDTByOrganize(UserInfo userInfo, string organizeId)
{
var dataTable = new DataTable(PiUserTable.TableName);
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.MessageService_GetUserDTByOrganize);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var userManager = new PiUserManager(dbProvider, userInfo);
string sqlQuery = " SELECT " + PiUserTable.TableName + ".* "
+ "," + PiUserLogOnTable.TableName + "." + PiUserLogOnTable.FieldUserOnLine
+ " FROM PIUSER LEFT OUTER JOIN PIUSERLOGON ON PIUSER.ID = PIUSERLOGON.ID "
+ " WHERE (" + PiUserTable.TableName + "." + PiUserTable.FieldDeleteMark + " = 0 "
+ " AND " + PiUserTable.TableName + "." + PiUserTable.FieldEnabled + " = 1 "
+ " AND " + PiUserTable.TableName + "." + PiUserTable.FieldIsVisible + " = 1 ) ";
if (!String.IsNullOrEmpty(organizeId))
{
// 绑定在工作组上的
sqlQuery += " AND ((" + PiUserTable.TableName + "." + PiUserTable.FieldWorkgroupId + " = '" + organizeId + "') ";
// 绑定在部门上的
sqlQuery += " OR (" + PiUserTable.TableName + "." + PiUserTable.FieldDepartmentId + " = '" + organizeId + "' AND " + PiUserTable.TableName + "." + PiUserTable.FieldWorkgroupId + " IS NULL) ";
// 绑定在公司上的
sqlQuery += " OR (" + PiUserTable.TableName + "." + PiUserTable.FieldCompanyId + " = '" + organizeId + "' AND " + PiUserTable.TableName + "." + PiUserTable.FieldDepartmentId + " IS NULL AND " + PiUserTable.TableName + "." + PiUserTable.FieldWorkgroupId + " IS NULL)) ";
}
sqlQuery += " ORDER BY " + PiUserTable.TableName + "." + PiUserTable.FieldSortCode;
dataTable = userManager.Fill(sqlQuery);
dataTable.TableName = PiUserTable.TableName;
});
return(dataTable);
}
public int ClearUserRole(string userId)
{
var returnValue = 0;
var userManager = new PiUserManager(this.DBProvider, this.UserInfo);
returnValue += userManager.SetProperty(PiUserTable.FieldId, userId, PiUserTable.FieldRoleId, null);
returnValue += this.Delete(PiUserRoleTable.FieldUserId, userId);
return(returnValue);
}
public int EliminateRoleUser(string roleId)
{
var returnValue = 0;
var userManager = new PiUserManager(this.DBProvider, this.UserInfo);
returnValue = userManager.SetProperty(PiUserTable.FieldRoleId, roleId, PiUserTable.FieldRoleId, null);
returnValue += this.Delete(PiUserRoleTable.FieldRoleId, roleId);
return(returnValue);
}
/// <summary>
/// 根据用户名获取用户实体
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userName">用户名称</param>
/// <returns>用户实体</returns>
public PiUserEntity GetEntityByUserName(UserInfo userInfo, string userName)
{
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.UserService_GetEntity);
PiUserEntity userEntity = null;
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
userEntity = new PiUserManager(dbProvider, userInfo).GetEntityByUserName(userName);
});
return(userEntity);
}
/// <summary>
/// 按角色获取用户列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="roleIds">角色列表</param>
/// <returns>用户列表</returns>
public List <PiUserEntity> GetListByRole(UserInfo userInfo, string[] roleIds)
{
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.UserService_GetDTByRole);
var entityList = new List <PiUserEntity>();
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
entityList = new PiUserManager(dbProvider, userInfo).GetListByRole(roleIds);
});
return(entityList);
}
/// <summary>
/// 指定用户是否超级管理员
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userId">用户主键</param>
/// <returns>是否超级管理员，true：是，false：否</returns>
public bool IsAdministratorByUserId(UserInfo userInfo, string userId)
{
var returnValue = false;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.PermissionService_IsAdministratorByUserId);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
returnValue = new PiUserManager(dbProvider, userInfo).IsAdministrator(userId);
});
return(returnValue);
}
/// <summary>
/// 用户是否在某个组织架构里的判断
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userId">用户主键</param>
/// <param name="organizeName">部门名称</param>
/// <returns>存在</returns>
public bool UserIsInOrganize(UserInfo userInfo, string userId, string organizeName)
{
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.UserService_UserIsInOrganize);
bool result = false;
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var userManager = new PiUserManager(dbProvider, userInfo);
result = userManager.IsInOrganize(userId, organizeName);
});
return(result);
}
/// <summary>
/// 批量设置默认角色
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userIds">用户主键数组</param>
/// <param name="roleId">默认角色主键</param>
/// <returns>影响行数</returns>
public int BatchSetDefaultRole(UserInfo userInfo, string[] userIds, string roleId)
{
int returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.UserService_BatchSetDefaultRole);
ServiceUtil.ProcessRDIWriteDbWithTran(userInfo, parameter, dbProvider =>
{
var userManager = new PiUserManager(dbProvider, userInfo);
returnValue = userManager.SetProperty(userIds, PiUserTable.FieldRoleId, roleId);
});
return(returnValue);
}
/// <summary>
/// 查询用户
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="searchValue">查询</param>
/// <param name="auditStates">有效</param>
/// <param name="roleIds">用户角色</param>
/// <returns>数据表</returns>
public DataTable Search(UserInfo userInfo, string searchValue, string auditStates, string[] roleIds)
{
var dataTable = new DataTable(PiUserTable.TableName);
var parameter = ParameterUtil.CreateWithLog(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
dataTable = new PiUserManager(dbProvider, userInfo).Search(string.Empty, searchValue, roleIds, null, auditStates, string.Empty);
dataTable.TableName = PiUserTable.TableName;
});
return(dataTable);
}
/// <summary>
/// 按主键获取用户列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <returns>数据表</returns>
public List <PiUserEntity> GetListByIds(UserInfo userInfo, string[] ids)
{
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.UserService_GetDTByIds);
var entityList = new List <PiUserEntity>();
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, (dbHelper) =>
{
var userManager = new PiUserManager(dbHelper, userInfo);
entityList = userManager.GetList <PiUserEntity>(PiUserTable.FieldId, ids, PiUserTable.FieldSortCode);
});
return(entityList);
}
/// <summary>
/// 批量保存
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="dataTable">数据表</param>
/// <returns>影响行数</returns>
public int BatchSave(UserInfo userInfo, DataTable dataTable)
{
int returnValue = 0;
var parameter = ParameterUtil.CreateWithLog(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var userManager = new PiUserManager(dbProvider, userInfo);
returnValue = userManager.BatchSave(dataTable);
});
return(returnValue);
}
/// <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>
/// <returns>数据权限</returns>
public DataTable GetDTByRole(UserInfo userInfo, string roleId)
{
var dataTable = new DataTable(PiStaffTable.TableName);
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.UserService_GetDTByRole);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var userManager = new PiUserManager(dbProvider, userInfo);
dataTable = userManager.GetDTByRole(roleId);
dataTable.TableName = PiUserTable.TableName;
});
return(dataTable);
}
/// <summary>
/// 用户名是否重复
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="fieldNames">字段名</param>
/// <param name="fieldValues">字段值</param>
/// <returns>已存在</returns>
public bool Exists(UserInfo userInfo, string[] fieldNames, object[] fieldValues)
{
bool returnValue = false;
var parameter = ParameterUtil.CreateWithLog(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var userManager = new PiUserManager(dbProvider);
returnValue = userManager.Exists(fieldNames, fieldValues);
});
return(returnValue);
}
/// <summary>
/// 获得指定用户的所有权限列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userId">用户主键</param>
/// <returns>权限数据表</returns>
public DataTable GetPermissionDTByUserId(UserInfo userInfo, string userId)
{
var dataTable = new DataTable(PiPermissionItemTable.TableName);
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.PermissionService_GetPermissionDTByUserId);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
// 是否超级管理员
dataTable = new PiUserManager(dbProvider, userInfo).IsAdministrator(userId) ? new PiPermissionItemManager(dbProvider, userInfo).GetDT() : new PiPermissionManager(dbProvider).GetPermissionByUser(userId);
dataTable.TableName = PiPermissionItemTable.TableName;
});
return(dataTable);
}
/// <summary>
/// 添加短信，可以发给多个人
/// </summary>
/// <param name="messageEntity">实体</param>
/// <param name="receiverIds">接收者ID组</param>
/// <returns>影响行数</returns>
public int Send(CiMessageEntity messageEntity, string[] receiverIds, bool saveSend = true)
{
PiUserManager userManager = new PiUserManager(DBProvider, UserInfo);
// 每发一条短信，数据库中需要记录两条记录，他们的CreateUserId都为创建者ID。
// 接收者多人的话，不要重复设置创建人的记录了，即对发送者来说，只要记录一条记录就够了
int returnValue = 0;
messageEntity.CategoryCode = MessageCategory.Receiver.ToString();
messageEntity.IsNew = (int)MessageStateCode.New;
messageEntity.IPAddress = UserInfo.IPAddress;
messageEntity.ParentId = null;
messageEntity.DeleteMark = 0;
messageEntity.Enabled = 1;
returnValue++;
PiUserEntity userEntity = null;
for (int i = 0; i < receiverIds.Length; i++)
{
messageEntity.ParentId = null;
messageEntity.Id = Guid.NewGuid().ToString();
messageEntity.CategoryCode = MessageCategory.Receiver.ToString();
messageEntity.ReceiverId = receiverIds[i];
userEntity = userManager.GetEntity(receiverIds[i]);
if (userEntity != null && userEntity.Id != null)
{
messageEntity.ReceiverRealName = userEntity.RealName;
}
messageEntity.Enabled = 1;
messageEntity.IsNew = 1;
if (messageEntity.ReceiverId.Equals(UserInfo.Id))
{
messageEntity.IsNew = (int)MessageStateCode.Old;
}
// 接收信息
string parentId = this.Add(messageEntity, false, false);
if (saveSend)
{
// 已发送信息
messageEntity.Id = Guid.NewGuid().ToString();
messageEntity.ParentId = parentId;
messageEntity.CategoryCode = MessageCategory.Send.ToString();
messageEntity.DeleteMark = 0;
messageEntity.Enabled = 0;
this.Add(messageEntity, false, false);
}
returnValue++;
}
return(returnValue);
}
/// <summary>
/// 获取用户列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public DataTable GetDT(UserInfo userInfo)
{
var dataTable = new DataTable(PiUserTable.TableName);
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.UserService_GetDT);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
string[] names = { PiUserTable.FieldDeleteMark };
Object[] values = { 0 };
dataTable = new PiUserManager(dbProvider, userInfo).GetDT(names, values, PiUserTable.FieldSortCode);
dataTable.TableName = PiUserTable.TableName;
});
return(dataTable);
}
/// <summary>
/// 得到当前用户所在部门的用户列表
/// </summary>
/// <param name="userInfo">当前用户</param>
/// <returns>数据表</returns>
public DataTable GetDepartmentUser(UserInfo userInfo)
{
DataTable result = null;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.UserService_GetDepartmentUser);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var manager = new PiUserManager(dbProvider, userInfo);
string commandText = "SELECT " + PiUserTable.FieldId + "," + PiUserTable.FieldRealName + "," + PiUserTable.FieldCompanyName + "," + PiUserTable.FieldDepartmentName + " FROM " + PiUserTable.TableName + " WHERE " + PiUserTable.FieldCompanyName + " = '" + userInfo.CompanyName + "' AND " + PiUserTable.FieldDepartmentName + " = '" + userInfo.DepartmentName + "' AND " + PiUserTable.FieldDeleteMark + " = 0 AND " + PiUserTable.FieldEnabled + " = 1 AND " + PiUserTable.FieldIsVisible + " = 1 ORDER BY " + PiUserTable.FieldSortCode;
result = manager.Fill(commandText);
result.TableName = PiUserTable.TableName;
});
return(result);
}
public int RemoveFormRole(string[] userIds, string roleId)
{
var returnValue = 0;
var userManager = new PiUserManager(this.DBProvider, this.UserInfo);
for (var i = 0; i < userIds.Length; i++)
{
// 删除用户角色
returnValue += this.RemoveFormRole(userIds[i], roleId);
// 如果该角色是用户默认角色，将用户默认角色置空
userManager.SetProperty(PiUserTable.FieldId, userIds[i], PiUserTable.FieldRoleId, roleId, PiUserTable.FieldRoleId, null);
}
return(returnValue);
}
/// <summary>
/// 删除员工关联的用户
/// </summary>
/// <param name="staffId">员工主键</param>
/// <returns>影响行数</returns>
public int DeleteUser(string staffId)
{
int returnValue = 0;
string userId = this.GetEntity(staffId).UserId.ToString();
if (!String.IsNullOrEmpty(userId))
{
// 删除用户
PiUserManager userManager = new PiUserManager(DBProvider, UserInfo);
returnValue += userManager.SetDeleted(userId);
}
// 将员工的用户设置为空
returnValue += this.SetProperty(staffId, PiStaffTable.FieldUserId, null);
return(returnValue);
}
/// <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.UserService_SetDeleted);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
returnValue = new PiUserManager(dbProvider, userInfo).SetDeleted(ids);
if (ids != null && ids.Length > 0)
{
returnValue += ids.Sum(userId => new UserPermissionManager(dbProvider, userInfo).ClearUserPermissionByUserId(userId));
}
});
return(returnValue);
}
