/// <summary>
/// 授予资源的权限
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="resourceCategory">资源分类</param>
/// <param name="resourceId">资源主键</param>
/// <param name="grantPermissionItemIds">操作权限主键</param>
/// <returns>影响的行数</returns>
public int GrantResourcePermission(UserInfo userInfo, string resourceCategory, string resourceId, string[] grantPermissionItemIds)
{
var returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.PermissionService_GrantResourcePermission);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
if (grantPermissionItemIds != null)
{
var permissionManager = new PiPermissionManager(dbProvider, userInfo);
for (int i = 0; i < grantPermissionItemIds.Length; i++)
{
var resourcePermissionEntity = new PiPermissionEntity
{
ResourceCategory = resourceCategory,
ResourceId = resourceId,
PermissionId = grantPermissionItemIds[i],
Enabled = 1,
DeleteMark = 0
};
permissionManager.Add(resourcePermissionEntity);
returnValue++;
}
}
});
return(returnValue);
}
/// <summary>
/// 按日期获取日志
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="beginDate">开始时间</param>
/// <param name="endDate">结束时间</param>
/// <param name="userId">用户主键</param>
/// <param name="moduleId">模块主键</param>
/// <returns>数据表</returns>
public DataTable GetDTByDate(UserInfo userInfo, string beginDate, string endDate, string userId, string moduleId)
{
var dataTable = new DataTable(CiLogTable.TableName);
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.LogService_GetDTByDate);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var logManager = new LogManager(dbProvider, userInfo);
if (!string.IsNullOrEmpty(userId))
{
dataTable = logManager.GetDTByDateByUserIds(new[] { userId }, CiLogTable.FieldProcessId, moduleId, beginDate, endDate);
}
else
{
if (userInfo.IsAdministrator)
{
dataTable = logManager.GetDTByDate(CiLogTable.FieldProcessId, moduleId, beginDate, endDate);
}
else
{
var piPermissionScopeManager = new PiPermissionScopeManager(dbProvider, userInfo);
string[] userIds = piPermissionScopeManager.GetUserIds(userInfo.Id, "Resource.ManagePermission");
dataTable = logManager.GetDTByDateByUserIds(userIds, CiLogTable.FieldProcessId, moduleId, beginDate, endDate);
}
}
dataTable.TableName = CiLogTable.TableName;
});
return(dataTable);
}
/// <summary>
/// 获取数据权限目标主键
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="resourceCategory">资源类别</param>
/// <param name="targetId">目标资源主键</param>
/// <param name="targetResourceCategory">目标资源类别</param>
/// <param name="permissionItemCode">操作权限编号</param>
/// <returns>资源主键数组</returns>
public string[] GetPermissionScopeResourceIds(UserInfo userInfo, string resourceCategory, string targetId, string targetResourceCategory, string permissionItemCode)
{
string[] returnValue = null;
var parameter = ParameterUtil.CreateWithLog(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var permissionItemManager = new PiPermissionItemManager(dbProvider, userInfo);
var permissionItemId = permissionItemManager.GetId(PiPermissionItemTable.FieldCode, permissionItemCode);
var names = new string[6];
var values = new object[6];
names[0] = PiPermissionScopeTable.FieldResourceCategory;
values[0] = resourceCategory;
names[1] = PiPermissionScopeTable.FieldTargetId;
values[1] = targetId;
names[2] = PiPermissionScopeTable.FieldPermissionId;
values[2] = permissionItemId;
names[3] = PiPermissionScopeTable.FieldTargetCategory;
values[3] = targetResourceCategory;
names[4] = PiPermissionScopeTable.FieldDeleteMark;
values[4] = 0;
names[5] = PiPermissionScopeTable.FieldEnabled;
values[5] = 1;
returnValue = DbCommonLibary.GetIds(dbProvider, PiPermissionScopeTable.TableName, names, values, PiPermissionScopeTable.FieldResourceId);
});
return(returnValue);
}
/// <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="linkName">数据库连接定义名称</param>
/// <returns>数据库连接定义实体</returns>
public CiDbLinkDefineEntity GetEntityByLinkName(UserInfo userInfo, string linkName)
{
CiDbLinkDefineEntity entity = null;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, string.Empty);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var manager = new CiDbLinkDefineManager(dbProvider, userInfo);
var names = new string[3];
var values = new object[3];
names[0] = CiDbLinkDefineTable.FieldLinkName;
names[1] = CiDbLinkDefineTable.FieldEnabled;
names[2] = CiDbLinkDefineTable.FieldDeleteMark;
values[0] = linkName;
values[1] = 1;
values[2] = 0;
var dtTemp = manager.GetDT(names, values);
if (dtTemp != null && dtTemp.Rows.Count > 0)
{
entity = BaseEntity.Create <CiDbLinkDefineEntity>(dtTemp);
}
});
return(entity);
}
/// <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="userInfo">用户</param>
/// <param name="organizeId">组织机构主键</param>
/// <param name="roleId">角色主键</param>
/// <param name="contents">内容</param>
/// <returns></returns>
public string SendGroupMessage(UserInfo userInfo, string organizeId, string roleId, string contents)
{
int returnValue = 0;
var parameter = ParameterUtil.CreateWithLog(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var messageEntity = new CiMessageEntity
{
Id = BusinessLogic.NewGuid(),
CategoryCode = MessageCategory.Send.ToString(),
MSGContent = contents,
IsNew = (int)MessageStateCode.New,
ReadCount = 0,
DeleteMark = 0,
Enabled = 1
};
if (!string.IsNullOrEmpty(organizeId))
{
messageEntity.FunctionCode = MessageFunction.OrganizeMessage.ToString();
messageEntity.ObjectId = organizeId;
}
if (!string.IsNullOrEmpty(roleId))
{
messageEntity.FunctionCode = MessageFunction.RoleMessage.ToString();
messageEntity.ObjectId = roleId;
}
var messageManager = new CiMessageManager(dbProvider, userInfo);
returnValue = messageManager.BatchSend(string.Empty, organizeId, roleId, messageEntity, false);
});
return(returnValue.ToString());
}
/// <summary>
/// 发送系统提示消息
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="receiverId">接收者主键</param>
/// <param name="contents">内容</param>
/// <returns>主键</returns>
public string Remind(UserInfo userInfo, string receiverId, string contents)
{
string returnValue = string.Empty;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, "发送系统提示消息");
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var entity = new CiMessageEntity
{
Id = BusinessLogic.NewGuid(),
CategoryCode = MessageCategory.Receiver.ToString(),
FunctionCode = MessageFunction.Remind.ToString(),
ReceiverId = receiverId,
MSGContent = contents,
IsNew = (int)MessageStateCode.New,
ReadCount = 0,
DeleteMark = 0,
Enabled = 1
};
var manager = new CiMessageManager(dbProvider, userInfo);
returnValue = manager.Add(entity);
});
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);
}
/// <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="userId">用户主键</param>
/// <param name="permissionItemCode">权限域编号</param>
/// <returns>数据表</returns>
public DataTable GetPermissionItemDTByPermissionScope(UserInfo userInfo, string userId, string permissionItemCode)
{
var dataTable = new DataTable(PiPermissionItemTable.TableName);
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.PermissionService_GetPermissionItemDTByPermissionScope);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var permissionItemManager = new PiPermissionItemManager(dbProvider, userInfo);
var permissionItemId = permissionItemManager.GetId(PiPermissionItemTable.FieldCode, permissionItemCode);
// 数据库里没有设置可授权的权限项，系统自动增加一个权限配置项
if (String.IsNullOrEmpty(permissionItemId) && permissionItemCode.Equals("Resource.ManagePermission"))
{
var permissionItemEntity = new PiPermissionItemEntity
{
Code = "Resource.ManagePermission",
FullName = "资源管理范围权限（系统默认）",
IsScope = 1,
Enabled = 1,
AllowDelete = 0
};
permissionItemManager.AddEntity(permissionItemEntity);
}
dataTable = permissionItemManager.GetDTByUser(userId, permissionItemCode);
dataTable.TableName = PiPermissionItemTable.TableName;
});
return(dataTable);
}
/// <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="resourceCategory">资源分类</param>
/// <param name="resourceId">资源主键</param>
/// <param name="revokePermissionItemIds">操作权限主键</param>
/// <returns>影响的行数</returns>
public int RevokeResourcePermission(UserInfo userInfo, string resourceCategory, string resourceId, string[] revokePermissionItemIds)
{
var returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.PermissionService_RevokeResourcePermission);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
if (revokePermissionItemIds != null)
{
var permissionManager = new PiPermissionManager(dbProvider, userInfo);
string[] names = new string[3];
string[] values = new string[3];
names[0] = PiPermissionTable.FieldResourceCategory;
values[0] = resourceCategory;
names[1] = PiPermissionTable.FieldResourceId;
values[1] = resourceId;
names[2] = PiPermissionTable.FieldPermissionId;
for (int i = 0; i < revokePermissionItemIds.Length; i++)
{
values[2] = revokePermissionItemIds[i];
// returnValue += permissionManager.SetDeleted(names, values);
returnValue += permissionManager.Delete(names, values);
}
}
});
return(returnValue);
}
/// <summary>
/// 用户离线
/// </summary>
/// <param name="userInfo">用户</param>
public void OnExit(UserInfo userInfo)
{
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.LogOnService_OnExit);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var manager = new PiUserLogOnManager(dbProvider, userInfo);
manager.OnExit(userInfo.Id);
});
}
/// <summary>
/// 全部清除异常
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public void Truncate(UserInfo userInfo)
{
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.ExceptionService_Truncate);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var exceptionManager = new CiExceptionManager(dbProvider, userInfo);
exceptionManager.Truncate();
});
}
/// <summary>
/// 清除用户归属的角色
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userId">用户主键</param>
/// <returns>影响行数</returns>
public int ClearUserRole(UserInfo userInfo, string userId)
{
int returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.UserService_ClearUserRole, "用户：" + userId);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
returnValue = new PiUserRoleManager(dbProvider, userInfo).ClearUserRole(userId);
});
return(returnValue);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
/// 组织机构模块关联关系相关
//////////////////////////////////////////////////////////////////////////////////////////////////////
#region public string[] GetScopeModuleIdsByOrganizeId(UserInfo userInfo, string organizeId, string permissionItemCode) 获取指定组织机构在某个权限域下所有模块主键数组
/// <summary>
/// 获取指定组织机构在某个权限域下所有模块主键数组
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="organizeId">组织机构主键</param>
/// <param name="permissionItemCode">操作权限编号</param>
/// <returns>组织机构主键数组</returns>
public string[] GetScopeModuleIdsByOrganizeId(UserInfo userInfo, string organizeId, string permissionItemCode)
{
string[] returnValue = null;
var parameter = ParameterUtil.CreateWithLog(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
returnValue = new OrganizeScopeManage(dbProvider, userInfo, PiPermissionScopeTable.TableName).GetModuleIds(organizeId, permissionItemCode);
});
return(returnValue);
}
/// <summary>
/// 获取组织机构主键数组通过指定操作权限
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="permissionItemId">操作权限主键</param>
/// <returns>主键数组</returns>
public string[] GetOrganizeIdsByPermissionItemId(UserInfo userInfo, string permissionItemId)
{
string[] returnValue = null;
var parameter = ParameterUtil.CreateWithLog(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
returnValue = new OrganizePermissionManager(dbProvider, userInfo, PiPermissionTable.TableName).GetOrganizeIds(permissionItemId);
});
return(returnValue);
}
/// <summary>
/// 获得指定用户的数据权限范围
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userId">用户主键</param>
/// <param name="permissionItemCode">数据权限编号</param>
/// <returns>数据权限范围</returns>
public PermissionScope GetPermissionScopeByUserId(UserInfo userInfo, string userId, string permissionItemCode)
{
var returnValue = PermissionScope.None;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.PermissionService_GetPermissionScopeByUserId);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
returnValue = new PiPermissionScopeManager(dbProvider, userInfo).GetUserPermissionScope(userId, permissionItemCode);
});
return(returnValue);
}
/// <summary>
/// 批量删除用户组织机构关联
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <returns>影响行数</returns>
public int BatchDeleteUserOrganize(UserInfo userInfo, string[] ids)
{
int returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.UserService_BatchDeleteUserOrganize, "主键数组：" + BusinessLogic.ArrayToList(ids));
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
returnValue = new PiUserOrganizeManager(dbProvider, userInfo).Delete(ids);
});
return(returnValue);
}
/// <summary>
/// 删除实体
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="tableName">目标表</param>
/// <param name="id">主键</param>
/// <returns>影响的行数</returns>
public int Delete(UserInfo userInfo, string tableName, string id)
{
int returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.ItemsService_Delete);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
returnValue = new CiItemsManager(dbProvider, userInfo, tableName).Delete(id);
});
return(returnValue);
}
/// <summary>
/// 移动实体
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="id">主键</param>
/// <param name="parentId">父主键</param>
/// <returns>影响行数</returns>
public int MoveToQueryEngine(UserInfo userInfo, string id, string parentId)
{
var returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.QueryEnginService_MoveTo, "权限项主键：" + id + ",父主键:" + parentId);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
returnValue = new QueryEngineManager(dbProvider, userInfo).MoveTo(id, parentId);
});
return(returnValue);
}
/// <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="id">主键</param>
/// <returns>实体</returns>
public CiMessageEntity GetEntity(UserInfo userInfo, string id)
{
CiMessageEntity entity = null;
var parameter = ParameterUtil.CreateWithOutMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
entity = new CiMessageManager(dbProvider, userInfo).GetEntity(id);
});
return(entity);
}
/// <summary>
/// 获取实体
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="id">主鍵</param>
/// <returns>实体</returns>
public PiStaffEntity GetEntity(UserInfo userInfo, string id)
{
PiStaffEntity entity = null;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.StaffService_GetEntity);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
entity = new PiStaffManager(dbProvider, userInfo).GetEntity(id);
});
return(entity);
}
/// <summary>
/// 获取角色主键数组通过指定操作权限
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="permissionItemId">操作权限主键</param>
/// <returns>主键数组</returns>
public string[] GetRoleIdsByPermissionItemId(UserInfo userInfo, string permissionItemId)
{
string[] returnValue = null;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.PermissionService_GetRoleIdsByPermissionItemId);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
returnValue = new RolePermissionManager(dbProvider, userInfo).GetRoleIds(permissionItemId);
});
return(returnValue);
}
public byte[] GetTheLatestAddIn(UserInfo userInfo, string Id)
{
var dtAddIn = new DataTable(PiPlatFormAddInTable.TableName);
var parameter = ParameterUtil.CreateWithLog(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
dtAddIn = new PiPlatFormAddInManager(dbProvider, userInfo).GetDTById(Id);
});
return(BusinessLogic.GetBinaryFormatData(dtAddIn));
}
/// <summary>
/// 批量删除
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <returns>影响行数</returns>
public int BatchDelete(UserInfo userInfo, string[] ids)
{
int returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.StaffService_BatchDelete);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
returnValue = new PiStaffManager(dbProvider, userInfo).BatchDelete(ids);
});
return(returnValue);
}
/// <summary>
/// 获取用户角色列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userId">用户主键</param>
/// <returns>主键数组</returns>
public string[] GetAllUserRoleIds(UserInfo userInfo, string userId)
{
string[] returnValue = null;
var parameter = ParameterUtil.CreateWithLog(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
returnValue = new PiUserRoleManager(dbProvider, userInfo).GetAllRoleIds(userId);
});
return(returnValue);
}