/// <summary>
/// 判断是否存在
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="folderId">文件夹主键</param>
/// <param name="fileName">文件名</param>
/// <returns>存在</returns>
public bool Exists(BaseUserInfo userInfo, string folderId, string fileName)
{
// 写入调试信息
#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);
BaseFileManager fileManager = new BaseFileManager(dbHelper, userInfo);
//returnValue = fileManager.Exists(new KeyValuePair<string, object>(BaseFileEntity.FieldFolderId, folderId), new KeyValuePair<string, object>(BaseFileEntity.FieldFileName, fileName));
//加入删除状态为0的条件
List <KeyValuePair <string, object> > parametersList = new List <KeyValuePair <string, object> >();
parametersList.Add(new KeyValuePair <string, object>(BaseFileEntity.FieldFolderId, folderId));
parametersList.Add(new KeyValuePair <string, object>(BaseFileEntity.FieldFileName, fileName));
parametersList.Add(new KeyValuePair <string, object>(BaseFileEntity.FieldDeletionStateCode, 0));
returnValue = fileManager.Exists(parametersList);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.FileService_Exists, 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="roleId">角色主键</param>
/// <param name="userIds">用户主键</param>
/// <returns>影响行数</returns>
public int RemoveUserFromRole(BaseUserInfo userInfo, string roleId, string[] userIds)
{
// 写入调试信息
#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);
dbHelper.BeginTransaction();
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
if (userIds != null)
{
returnValue += userManager.RemoveFormRole(userIds, roleId);
}
BaseLogManager.Instance.Add(dbHelper, userInfo, serviceName, AppMessage.RoleService_RemoveUserFromRole, 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="userInfo">用户</param>
/// <param name="workFlowId">工作流主键</param>
/// <returns>数据表</returns>
public DataTable GetDataTable(BaseUserInfo userInfo, string workFlowId)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
DataTable dataTable = new DataTable(BaseWorkFlowProcessEntity.TableName);
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.WorkFlowDbType))
{
try
{
dbHelper.Open(WorkFlowDbConnection);
BaseWorkFlowActivityManager workFlowActivityManager = new BaseWorkFlowActivityManager(dbHelper, userInfo);
List <KeyValuePair <string, object> > parameters = new List <KeyValuePair <string, object> >();
parameters.Add(new KeyValuePair <string, object>(BaseWorkFlowStepEntity.FieldWorkFlowId, workFlowId));
parameters.Add(new KeyValuePair <string, object>(BaseWorkFlowStepEntity.FieldEnabled, 1));
parameters.Add(new KeyValuePair <string, object>(BaseWorkFlowStepEntity.FieldDeletionStateCode, 0));
dataTable = workFlowActivityManager.GetDataTable(parameters, BaseWorkFlowActivityEntity.FieldSortCode);
dataTable.TableName = BaseWorkFlowActivityEntity.TableName;
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}
}
// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return(dataTable);
}
// #region public DataTable GetLogGeneralForOnlineUser(BaseUserInfo userInfo) 获取用户访问情况日志
// /// <summary>
// /// 获取用户访问情况日志
// /// </summary>
// /// <param name="userInfo">用户</param>
// /// <returns>数据表</returns>
// public DataTable GetLogGeneralForOnlineUser(BaseUserInfo userInfo, bool UserOnLine)
// {
// // 写入调试信息
// #if (DEBUG)
// int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
// #endif
// // 加强安全验证防止未授权匿名调用
// #if (!DEBUG)
// LogOnService.UserIsLogOn(userInfo);
// #endif
// DataTable dataTable = new DataTable(BaseLogEntity.TableName);
// using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
// {
// BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
// try
// {
// dbHelper.Open(UserCenterDbConnection);
// if (userInfo.IsAdministrator)
// {
// dataTable = userManager.GetDataTable();
// }
// else
// {
// BasePermissionScopeManager permissionScopeManager = new BasePermissionScopeManager(dbHelper, userInfo);
// string[] userIds = permissionScopeManager.GetUserIds(userInfo.Id, "Resource.ManagePermission");
// dataTable = userManager.GetDataTableByIds(userIds,UserOnLine);
// }
// dataTable.TableName = BaseLogEntity.TableName;
// BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.LogService_GetLogGeneral, 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;
// }
// #endregion
#region public DataTable ResetVisitInfo(BaseUserInfo userInfo, string[] ids) 重置用户访问情况
/// <summary>
/// 重置用户访问情况
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">日志主键</param>
/// <returns>数据表</returns>
public DataTable ResetVisitInfo(BaseUserInfo userInfo, string[] ids)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
DataTable dataTable = new DataTable(BaseLogEntity.TableName);
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
dbHelper.BeginTransaction();
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
// 重置访问情况
userManager.ResetVisitInfo(ids);
// 获取列表
dataTable = userManager.GetDataTable();
dataTable.TableName = BaseLogEntity.TableName;
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.LogService_ResetVisitInfo, 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(dataTable);
}
/// <summary>
/// 按主键数组获取列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">角色主键</param>
/// <returns>数据表</returns>
public DataTable GetDataTableByIds(BaseUserInfo userInfo, string[] ids)
{
// 写入调试信息
#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.GetDataTable(BaseRoleEntity.FieldId, ids, BaseRoleEntity.FieldSortCode);
dataTable.TableName = BaseRoleEntity.TableName;
BaseLogManager.Instance.Add(dbHelper, userInfo, serviceName, AppMessage.RoleService_GetDataTableByIds, 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="dataTable">数据表</param>
/// <returns>影响行数</returns>
public int BatchSave(BaseUserInfo userInfo, DataTable dataTable)
{
// 写入调试信息
#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 = BaseItemsEntity.TableName;
if (!string.IsNullOrEmpty(BaseSystemInfo.SystemCode))
{
tableName = BaseSystemInfo.SystemCode + "Items";
}
BaseItemsManager itemsManager = new BaseItemsManager(dbHelper, userInfo, tableName);
returnValue = itemsManager.BatchSave(dataTable);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.ItemsService_BatchSave, 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 GetDataTable(BaseUserInfo userInfo)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
DataTable dataTable = new DataTable(BasePermissionItemEntity.TableName);
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
string tableName = BasePermissionItemEntity.TableName;
if (!string.IsNullOrEmpty(BaseSystemInfo.SystemCode))
{
tableName = BaseSystemInfo.SystemCode + "PermissionItem";
}
BasePermissionItemManager permissionItemManager = new BasePermissionItemManager(dbHelper, userInfo, tableName);
dataTable = permissionItemManager.GetDataTable(new KeyValuePair <string, object>(BasePermissionItemEntity.FieldDeletionStateCode, 0), BasePermissionItemEntity.FieldSortCode);
dataTable.TableName = BasePermissionItemEntity.TableName;
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.PermissionItemService_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="userId">用户主键</param>
/// <param name="permissionItemCode">数据权限编号</param>
/// <returns>主键数组</returns>
public string[] GetUserIdsByPermissionScope(BaseUserInfo userInfo, string userId, string permissionItemCode)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
string[] returnValue = null;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
// 若权限是空的，直接返回所有数据
if (String.IsNullOrEmpty(permissionItemCode))
{
return(returnValue);
}
// 获得用户主键数组
BasePermissionScopeManager permissionScopeManager = new BasePermissionScopeManager(dbHelper, userInfo);
returnValue = permissionScopeManager.GetUserIds(userId, permissionItemCode);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.PermissionService_GetUserIdsByPermission, 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="codes">编号数组</param>
/// <returns>数据权限合</returns>
public DataSet GetDSByCodes(BaseUserInfo userInfo, string[] codes)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
DataSet dataSet = new DataSet();
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
for (int i = 0; i < codes.Length; i++)
{
DataTable dataTable = this.GetDataTableByCode(dbHelper, userInfo, codes[i]);
dataTable.TableName = codes[i];
dataSet.Tables.Add(dataTable);
}
// 添加日志
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.ItemDetailsService_GetDSByCodes, MethodBase.GetCurrentMethod());
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}
}
// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return(dataSet);
}
/// <summary>
/// 移除权限范围
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="resourceCategory">资源分类</param>
/// <param name="resourceIds">资源主键</param>
/// <param name="targetCategory">目标分类</param>
/// <param name="revokeTargetId">目标主键</param>
/// <param name="permissionItemId">操作权限项</param>
/// <returns>影响行数</returns>
public int RevokePermissionScopeTarget(BaseUserInfo userInfo, string resourceCategory, string[] resourceIds, string targetCategory, string revokeTargetId, string permissionItemId)
{
// 写入调试信息
#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 = BasePermissionScopeEntity.TableName;
if (!string.IsNullOrEmpty(BaseSystemInfo.SystemCode))
{
tableName = BaseSystemInfo.SystemCode + "PermissionScope";
}
BasePermissionScopeManager permissionScopeManager = new BasePermissionScopeManager(dbHelper, userInfo, tableName);
returnValue = permissionScopeManager.RevokeResourcePermissionScopeTarget(resourceCategory, resourceIds, targetCategory, revokeTargetId, permissionItemId);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, 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="sequenceEntity">序列实体</param>
/// <param name="statusCode">状态码</param>
/// <param name="statusMessage">状态信息</param>
/// <returns>影响行数</returns>
public int Update(BaseUserInfo userInfo, BaseSequenceEntity sequenceEntity, out string statusCode, out string statusMessage)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
statusCode = string.Empty;
statusMessage = string.Empty;
int returnValue = 0;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseSequenceManager sequenceManager = new BaseSequenceManager(dbHelper, userInfo);
// 编辑数据
returnValue = sequenceManager.Update(sequenceEntity, out statusCode);
// returnValue = businessCardManager.Update(businessCardEntity, out statusCode);
statusMessage = sequenceManager.GetStateMessage(statusCode);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.SequenceService_Update, 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="organizeId">组织机构主键</param>
/// <param name="parentId">父结点主键</param>
/// <returns>数据表</returns>
public int MoveTo(BaseUserInfo userInfo, string moduleId, string parentId)
{
// 写入调试信息
#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 = BaseModuleEntity.TableName;
if (!string.IsNullOrEmpty(BaseSystemInfo.SystemCode))
{
tableName = BaseSystemInfo.SystemCode + "Module";
}
BaseModuleManager moduleManager = new BaseModuleManager(dbHelper, userInfo, tableName);
returnValue = moduleManager.SetProperty(moduleId, new KeyValuePair <string, object>(BaseModuleEntity.FieldParentId, parentId));
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.ModuleService_MoveTo, 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="password">新密码</param>
/// <param name="returnStatusCode">返回状态码</param>
/// <param name="returnStatusMessage">返回状消息</param>
/// <returns>影响行数</returns>
public int SetPassword(BaseUserInfo userInfo, string[] userIds, string password, out string returnStatusCode, out string returnStatusMessage)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
returnStatusCode = string.Empty;
returnStatusMessage = string.Empty;
int returnValue = 0;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.LogOnService_SetPassword, MethodBase.GetCurrentMethod());
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
returnValue = userManager.BatchSetPassword(userIds, password);
returnStatusCode = userManager.ReturnStatusCode;
// 获得状态消息
returnStatusMessage = userManager.GetStateMessage(returnStatusCode);
}
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="staffEntites">实体</param>
/// <returns>影响行数</returns>
public int BatchUpdateAddress(BaseUserInfo userInfo, List <BaseStaffEntity> staffEntites, out string statusCode, out string statusMessage)
{
// 写入调试信息
#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);
statusCode = string.Empty;
BaseStaffManager staffManager = new BaseStaffManager(dbHelper, userInfo);
for (int i = 0; i < staffEntites.Count; i++)
{
returnValue += staffManager.UpdateAddress(staffEntites[i], out statusCode);
}
statusMessage = staffManager.GetStateMessage(statusCode);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.StaffService_BatchUpdateAddress, 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);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
/// 组织机构模块关联关系相关
//////////////////////////////////////////////////////////////////////////////////////////////////////
#region public string[] GetOrganizeScopeModuleIds(BaseUserInfo userInfo, string organizeId, string permissionItemCode)
/// <summary>
/// 获取用户模块权限范围主键数组
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="organizeId">组织机构主键</param>
/// <param name="permissionItemCode">权限编号</param>
/// <returns>主键数组</returns>
public string[] GetOrganizeScopeModuleIds(BaseUserInfo userInfo, string organizeId, string permissionItemCode)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
string[] returnValue = null;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
string tableName = BaseOrganizeEntity.TableName;
if (!string.IsNullOrEmpty(BaseSystemInfo.SystemCode))
{
tableName = BaseSystemInfo.SystemCode + "PermissionScope";
}
BaseOrganizeScopeManager organizeScopeManager = new BaseOrganizeScopeManager(dbHelper, userInfo, tableName);
returnValue = organizeScopeManager.GetModuleIds(organizeId, permissionItemCode);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.PermissionService_GetOrganizeScopeModuleIds, 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="code">编号</param>
/// <returns>实体</returns>
public BasePermissionItemEntity GetEntityByCode(BaseUserInfo userInfo, string code)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
BasePermissionItemEntity permissionItemEntity = null;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
string tableName = BasePermissionItemEntity.TableName;
if (!string.IsNullOrEmpty(BaseSystemInfo.SystemCode))
{
tableName = BaseSystemInfo.SystemCode + "PermissionItem";
}
BasePermissionItemManager permissionItemManager = new BasePermissionItemManager(dbHelper, userInfo, tableName);
permissionItemEntity = new BasePermissionItemEntity(permissionItemManager.GetDataTableByCode(code));
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.PermissionItemService_GetEntityByCode, MethodBase.GetCurrentMethod());
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}
}
// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return(permissionItemEntity);
}
/// <summary>
/// 获取消息状态
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="onLineState">用户在线状态</param>
/// <param name="lastChekDate">最后检查日期</param>
/// <returns>消息状态数组</returns>
public string[] MessageChek(BaseUserInfo userInfo, int onLineState, string lastChekDate)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
string[] returnValue = null;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
// 设置为在线状态
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
userManager.OnLine(userInfo.Id, onLineState);
// 读取信息状态
BaseMessageManager messageManager = new BaseMessageManager(dbHelper, userInfo);
returnValue = messageManager.MessageChek();
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.MessageService_MessageChek, 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="folderId">文件夹主键</param>
/// <param name="fileName">文件名</param>
/// <param name="file"></param>
/// <param name="description"></param>
/// <param name="enabled"></param>
/// <param name="statusCode"></param>
/// <param name="statusMessage"></param>
/// <returns></returns>
public string Add(BaseUserInfo userInfo, string folderId, string fileName, byte[] file, string description, bool enabled, out string statusCode, out string statusMessage)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
statusCode = string.Empty;
statusMessage = string.Empty;
string returnValue = string.Empty;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseFileManager fileManager = new BaseFileManager(dbHelper, userInfo);
returnValue = fileManager.Add(folderId, fileName, file, description, enabled, out statusCode);
statusMessage = fileManager.GetStateMessage(statusCode);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, 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="tableName">目标表</param>
/// <param name="ids">编码主键数组</param>
/// <param name="targetId">目标主键</param>
/// <returns>影响行数</returns>
public int BatchMoveTo(BaseUserInfo userInfo, string tableName, 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);
BaseItemsManager itemsManager = new BaseItemsManager(dbHelper, userInfo, tableName);
for (int i = 0; i < ids.Length; i++)
{
returnValue += itemsManager.SetProperty(ids[i], new KeyValuePair <string, object>(BaseItemsEntity.FieldParentId, targetId));
}
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.ItemsService_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);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
/// 资源权限设定关系相关
//////////////////////////////////////////////////////////////////////////////////////////////////////
#region public string[] GetResourcePermissionItemIds(BaseUserInfo userInfo, string resourceCategory, string resourceId)
/// <summary>
/// 获取资源权限主键数组
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="resourceCategory">资源分类</param>
/// <returns>主键数组</returns>
public string[] GetResourcePermissionItemIds(BaseUserInfo userInfo, string resourceCategory, string resourceId)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
string[] returnValue = null;
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>(BasePermissionEntity.FieldResourceCategory, resourceCategory));
parameters.Add(new KeyValuePair <string, object>(BasePermissionEntity.FieldResourceId, resourceId));
DataTable dataTable = DbLogic.GetDataTable(dbHelper, BasePermissionEntity.TableName, parameters);
returnValue = BaseBusinessLogic.FieldToArray(dataTable, BasePermissionEntity.FieldPermissionItemId);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.PermissionService_GetResourcePermissionItemIds, 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="id">主键</param>
/// <returns>数据表</returns>
public BaseItemDetailsEntity GetEntityByCode(BaseUserInfo userInfo, string tableName, string code)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
BaseItemDetailsEntity itemDetailsEntity = new BaseItemDetailsEntity();
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseItemDetailsManager itemDetailsManager = new BaseItemDetailsManager(dbHelper, userInfo, tableName);
DataTable datatable = itemDetailsManager.GetDataTable(new KeyValuePair <string, object>(BaseItemDetailsEntity.FieldItemCode, code), BaseItemDetailsEntity.FieldSortCode);
if ((datatable != null) && (datatable.Rows.Count > 0))
{
itemDetailsEntity = itemDetailsEntity.GetFrom(datatable.Rows[0]);
}
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.ItemDetailsService_GetEntity, MethodBase.GetCurrentMethod());
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}
}
// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return(itemDetailsEntity);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="dataTable">数据表</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状态信息</param>
/// <returns>数据表</returns>
public string Add(BaseUserInfo userInfo, string tableName, BaseItemDetailsEntity itemDetailsEntity, 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;
statusCode = string.Empty;
statusMessage = string.Empty;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseItemDetailsManager itemDetailsManager = new BaseItemDetailsManager(dbHelper, userInfo, tableName);
// 调用方法，并且返回运行结果
returnValue = itemDetailsManager.Add(itemDetailsEntity, out statusCode);
statusMessage = itemDetailsManager.GetStateMessage(statusCode);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.ItemDetailsService_Add, 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="id">主键</param>
/// <param name="auditIdea">审核意见</param>
/// <returns>影响行数</returns>
public int AuditComplete(BaseUserInfo userInfo, string[] ids, string auditIdea)
{
// 写入调试信息
#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.WorkFlowDbType))
{
try
{
dbHelper.Open(WorkFlowDbConnection);
//IWorkFlowManager userReportManager = new UserReportManager(userInfo);
BaseWorkFlowCurrentManager workFlowCurrentManager = new BaseWorkFlowCurrentManager(dbHelper, userInfo);
dbHelper.BeginTransaction();
returnValue += workFlowCurrentManager.AuditComplete(ids, auditIdea);
dbHelper.CommitTransaction();
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, MethodBase.GetCurrentMethod());
}
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="userInfo">用户</param>
/// <param name="parentId">父主键</param>
/// <param name="code">编号</param>
/// <param name="fullName">全称</param>
/// <param name="categoryId">分类</param>
/// <param name="outerPhone">外线</param>
/// <param name="innerPhone">内线</param>
/// <param name="fax">传真</param>
/// <param name="enabled">有效</param>
/// <param name="statusCode">状态码</param>
/// <param name="statusMessage">状态信息</param>
/// <returns>主键</returns>
public string AddByDetail(BaseUserInfo userInfo, string parentId, string code, string fullName, string categoryId, string outerPhone, string innerPhone, string fax, bool enabled, out string statusCode, out string statusMessage)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
statusCode = string.Empty;
statusMessage = string.Empty;
string returnValue = string.Empty;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseOrganizeManager organizeManager = new BaseOrganizeManager(dbHelper, userInfo);
returnValue = organizeManager.AddByDetail(parentId, code, fullName, categoryId, outerPhone, innerPhone, fax, enabled, out statusCode);
statusMessage = organizeManager.GetStateMessage(statusCode);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.OrganizeService_AddByDetail, 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="organizeId">组织机构主键</param>
/// <param name="revokeModuleIds">撤消模块主键数组</param>
/// <returns>影响的行数</returns>
public int RevokeOrganizeModuleScopes(BaseUserInfo userInfo, string organizeId, string permissionItemCode, string[] revokeModuleIds)
{
// 写入调试信息
#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);
BaseOrganizeScopeManager organizeScopeManager = new BaseOrganizeScopeManager(dbHelper, userInfo);
// 小心异常，检查一下参数的有效性
if (revokeModuleIds != null)
{
returnValue += organizeScopeManager.RevokeModules(organizeId, permissionItemCode, revokeModuleIds);
}
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.PermissionService_RevokeOrganizeModuleScopes, 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="addRoleIds">加入角色</param>
/// <returns>影响的行数</returns>
public int AddUserToRole(BaseUserInfo userInfo, string userId, string[] addRoleIds)
{
// 写入调试信息
#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);
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
// 小心异常，检查一下参数的有效性
if (addRoleIds != null)
{
returnValue += userManager.AddToRole(userId, addRoleIds);
}
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, 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="organizeIds">主键数组</param>
/// <param name="parentId">父节点主键</param>
/// <returns>影响行数</returns>
public int BatchMoveTo(BaseUserInfo userInfo, string[] organizeIds, string parentId)
{
// 写入调试信息
#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);
BaseOrganizeManager organizeManager = new BaseOrganizeManager(dbHelper, userInfo);
for (int i = 0; i < organizeIds.Length; i++)
{
returnValue += organizeManager.MoveTo(organizeIds[i], parentId);
}
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.OrganizeService_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="id">员工主键</param>
/// <param name="companyId">单位主键</param>
/// <param name="departmentId">部门主键</param>
/// <returns>影响行数</returns>
public int ChangeDepartment(BaseUserInfo userInfo, string id, string companyId, string departmentId)
{
// 写入调试信息
#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);
BaseStaffManager staffManager = new BaseStaffManager(dbHelper, userInfo);
List <KeyValuePair <string, object> > parameters = new List <KeyValuePair <string, object> >();
parameters.Add(new KeyValuePair <string, object>(BaseStaffEntity.FieldCompanyId, companyId));
parameters.Add(new KeyValuePair <string, object>(BaseStaffEntity.FieldDepartmentId, departmentId));
returnValue = staffManager.SetProperty(new KeyValuePair <string, object>(BaseStaffEntity.FieldId, id), parameters);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, 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="organizeId">组织机构</param>
/// <param name="searchValue">查询</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(BaseOrganizeEntity.TableName);
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
// 获得组织机构列表
BaseOrganizeManager organizeManager = new BaseOrganizeManager(dbHelper, userInfo);
dataTable = organizeManager.Search(string.Empty, searchValue);
dataTable.DefaultView.Sort = BaseOrganizeEntity.FieldSortCode;
dataTable.TableName = BaseOrganizeEntity.TableName;
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.OrganizeService_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="userInfo">用户</param>
/// <param name="categoryId">单据分类主键</param>
/// <param name="objectId">单据主键</param>
/// <returns>数据权限</returns>
public DataTable GetAuditDetailDT(BaseUserInfo userInfo, string categoryId, string objectId)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
DataTable dataTable = null;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.WorkFlowDbType))
{
try
{
dbHelper.Open(WorkFlowDbConnection);
BaseWorkFlowCurrentManager workFlowCurrentManager = new BaseWorkFlowCurrentManager(dbHelper, userInfo);
string[] ids = workFlowCurrentManager.GetIds(new KeyValuePair <string, object>(BaseWorkFlowCurrentEntity.FieldCategoryCode, categoryId), new KeyValuePair <string, object>(BaseWorkFlowCurrentEntity.FieldObjectId, objectId));
BaseWorkFlowHistoryManager workFlowHistoryManager = new BaseWorkFlowHistoryManager(dbHelper, userInfo);
dataTable = workFlowHistoryManager.GetDataTable(BaseWorkFlowHistoryEntity.FieldCurrentFlowId, ids, BaseWorkFlowHistoryEntity.FieldCreateOn);
dataTable.TableName = BaseWorkFlowCurrentEntity.TableName;
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, 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);
}