/// <summary>
/// 用户是否在某个组织架构里的判断
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userId">用户主键</param>
/// <param name="organizeName">部门名称</param>
/// <returns>存在</returns>
public bool UserIsInOrganize(BaseUserInfo userInfo, string userId, string organizeName)
{
// 写入调试信息
#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);
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
returnValue = userManager.IsInOrganize(userId, organizeName);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.UserService_UserInRole, 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="permissionItemId">操作权限主键</param>
/// <returns>主键数组</returns>
public string[] GetIdsByPermission(BaseUserInfo userInfo, string permissionItemId)
{
// 写入调试信息
#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);
BasePermissionModuleManager modulePermissionManager = new BasePermissionModuleManager(dbHelper, userInfo);
returnValue = modulePermissionManager.GetModuleIds(permissionItemId);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.ModuleService_GetIdsByPermission, 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="organizeId">父结点主键</param>
/// <returns>影响行数</returns>
public int MoveTo(BaseUserInfo userInfo, string id, string organizeId)
{
// 写入调试信息
#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);
returnValue = staffManager.SetProperty(id, new KeyValuePair <string, object>(BaseStaffEntity.FieldDepartmentId, organizeId));
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="workFlowManager">流程控制管理器</param>
/// <param name="workFlowAuditInfo">流程信息</param>
/// <returns>影响行数</returns>
public string FreeAuditComplete(IWorkFlowManager workFlowManager, BaseWorkFlowAuditInfo workFlowAuditInfo)
{
// 返回值
string result = string.Empty;
// 这里用锁的机制，提高并发控制能力
lock (WorkFlowCurrentLock)
{
try
{
// 开始事务
this.DbHelper.BeginTransaction();
// 进行更新操作
this.StepAuditComplete(workFlowAuditInfo.Id, workFlowAuditInfo.AuditIdea);
BaseWorkFlowCurrentEntity workFlowCurrentEntity = this.GetObject(workFlowAuditInfo.Id);
// 发送提醒信息
if (workFlowManager != null)
{
workFlowManager.OnAutoAuditComplete(workFlowCurrentEntity);
workFlowManager.SendRemindMessage(workFlowCurrentEntity, AuditStatus.AuditComplete, new string[] { workFlowCurrentEntity.CreateUserId, workFlowAuditInfo.ToUserId }, workFlowAuditInfo.ToDepartmentId, workFlowAuditInfo.ToRoleId);
}
this.StatusMessage = this.GetStateMessage(this.StatusCode);
result = workFlowAuditInfo.Id;
this.DbHelper.CommitTransaction();
}
catch (Exception ex)
{
this.DbHelper.RollbackTransaction();
BaseExceptionManager.LogException(dbHelper, this.UserInfo, ex);
this.StatusCode = Status.Error.ToString();
// throw;
}
finally
{
this.DbHelper.Close();
}
return(result);
}
}
/// <summary>
/// 获取参数值
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="categoryId">分类主键</param>
/// <param name="parameterId">参数主键</param>
/// <param name="parameterCode">参数编号</param>
/// <returns>参数值</returns>
public string GetParameter(BaseUserInfo userInfo, string categoryId, string parameterId, string parameterCode)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
// #if (!DEBUG)
// LogOnService.UserIsLogOn(userInfo);
// #endif
string returnValue = string.Empty;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseParameterManager parameterManager = new BaseParameterManager(dbHelper, userInfo);
returnValue = parameterManager.GetParameter(categoryId, parameterId, parameterCode);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.ParameterService_GetParameter, 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(BaseSequenceEntity.TableName);
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseSequenceManager sequenceManager = new BaseSequenceManager(dbHelper);
dataTable = sequenceManager.GetDataTable();
dataTable.TableName = BaseSequenceEntity.TableName;
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.SequenceService_GetDataTable, MethodBase.GetCurrentMethod());
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}
}
// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return(dataTable);
}
/// <summary>
/// 批量删除
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">选种的数组</param>
/// <returns>数据权限</returns>
public int BatchDelete(BaseUserInfo userInfo, string[] ids)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
int returnValue = 0;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.WorkFlowDbType))
{
try
{
dbHelper.Open(WorkFlowDbConnection);
BaseWorkFlowActivityManager WorkFlowActivity = new BaseWorkFlowActivityManager(dbHelper, userInfo);
returnValue = WorkFlowActivity.Delete(ids);
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="ids">主键数组</param>
/// <returns>影响行数</returns>
public int BatchDeleteConstraint(BaseUserInfo userInfo, string[] ids)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
int returnValue = 0;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BasePermissionScopeManager manager = new BasePermissionScopeManager(dbHelper, userInfo);
returnValue = manager.SetDeleted(ids);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.TableColumnsService_BatchDeleteConstraint, 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="enabled">有效</param>
/// <returns>主键</returns>
public string Upload(BaseUserInfo userInfo, string folderId, string fileName, byte[] file, bool enabled)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
string returnValue = string.Empty;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseFileManager fileManager = new BaseFileManager(dbHelper, userInfo);
returnValue = fileManager.Upload(folderId, fileName, file, enabled);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.FileService_Upload, 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 int Truncate(BaseUserInfo userInfo)
{
// 写入调试信息
#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);
BaseExceptionManager exceptionManager = new BaseExceptionManager(dbHelper, userInfo);
exceptionManager.Truncate();
BaseLogManager.Instance.Add(dbHelper, userInfo, serviceName, AppMessage.ExceptionService_Truncate, 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="receiverIds">接受者主键数组</param>
/// <param name="organizeIds">组织机构主键数组</param>
/// <param name="roleIds">角色主键数组</param>
/// <param name="messageEntity">消息内容</param>
/// <returns>影响行数</returns>
public int BatchSend(BaseUserInfo userInfo, string[] receiverIds, string[] organizeIds, string[] roleIds, BaseMessageEntity messageEntity)
{
// 写入调试信息
#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);
BaseMessageManager messageManager = new BaseMessageManager(dbHelper, userInfo);
returnValue = messageManager.BatchSend(receiverIds, organizeIds, roleIds, messageEntity, true);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.MessageService_BatchSend, 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 BaseFileEntity GetEntity(BaseUserInfo userInfo, string id)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
BaseFileEntity fileEntity = null;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseFileManager fileManager = new BaseFileManager(dbHelper, userInfo);
fileEntity = fileManager.GetEntity(id);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.FileService_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(fileEntity);
}
/// <summary>
/// 获取约束条件
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="resourceCategory">资源类别</param>
/// <param name="resourceId">资源主键</param>
/// <param name="tableName">表名</param>
/// <returns>约束条件</returns>
public string GetConstraint(BaseUserInfo userInfo, string resourceCategory, string resourceId, string tableName)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
string returnValue = string.Empty;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseTableColumnsManager manager = new BaseTableColumnsManager(dbHelper, userInfo);
returnValue = manager.GetConstraint(resourceCategory, resourceId, tableName);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.TableColumnsService_SetConstraint, 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="categoryCode"></param>
/// <param name="searchValue"></param>
/// <param name="enabled"></param>
/// <param name="deletionStateCode"></param>
/// <returns></returns>
public DataTable Search(BaseUserInfo userInfo, string userId, string categoryCode, string searchValue, bool?enabled, bool?deletionStateCode)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
DataTable dataTable = new DataTable(BaseWorkFlowBillTemplateEntity.TableName);
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.WorkFlowDbType))
{
try
{
dbHelper.Open(WorkFlowDbConnection);
BaseWorkFlowBillTemplateManager templateManager = new BaseWorkFlowBillTemplateManager(dbHelper, userInfo);
dataTable = templateManager.Search(userId, categoryCode, searchValue, enabled, deletionStateCode);
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);
}
/// <summary>
/// 获取内部通讯录
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="organizeId">组织机构主键</param>
/// <param name="search">查询内容</param>
/// <param name="pageSize">分页的条数</param>
/// <param name="pageIndex">当前页数</param>
/// <returns>数据表</returns>
public DataTable GetAddressDataTableByPage(BaseUserInfo userInfo, string organizeId, string searchValue, int pageSize, int pageIndex, out int recordCount)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
DataTable dataTable = new DataTable(BaseStaffEntity.TableName);
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseStaffManager staffManager = new BaseStaffManager(dbHelper, userInfo);
dataTable = staffManager.GetAddressDataTableByPage(out recordCount, pageSize, pageIndex, organizeId, searchValue);
dataTable.TableName = BaseStaffEntity.TableName;
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.StaffService_GetAddressPageDT, 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="parameters">字段名,字段值</param>
/// <returns>已存在</returns>
public bool Exists(BaseUserInfo userInfo, List <KeyValuePair <string, object> > parameters)
{
// 写入调试信息
#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);
BaseUserManager userManager = new BaseUserManager(dbHelper);
returnValue = userManager.Exists(parameters);
}
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="userEntity">用户实体</param>
/// <param name="statusCode">状态码</param>
/// <param name="statusMessage">状态信息</param>
/// <returns>主键</returns>
public string AddUser(BaseUserInfo userInfo, BaseUserEntity userEntity, out string statusCode, out string statusMessage)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
BaseSystemInfo.IsAuthorized(userInfo);
#endif
string returnValue = string.Empty;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
returnValue = AddUser(dbHelper, userInfo, userEntity, out statusCode, out statusMessage);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.UserService_AddUser, 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="fullName">序列名称</param>
/// <param name="count">个数</param>
/// <returns>序列号</returns>
public string[] GetBatchSequence(BaseUserInfo userInfo, string fullName, int count)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
string[] returnValue = new string[0];
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
returnValue = this.GetBatchSequence(dbHelper, userInfo, fullName, count);
}
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="id">评论主键数组</param>
/// <param name="worked">处理状态</param>
/// <returns>影响行数</returns>
public int SetWorked(string[] ids, int worked)
{
int result = 0;
string id = string.Empty;
try
{
DbHelper.BeginTransaction();
for (int i = 0; i < ids.Length; i++)
{
id = ids[i];
// result += this.SetProperty(id, BaseCommentEntity.FieldWorked, worked.ToString());
}
DbHelper.CommitTransaction();
}
catch (Exception ex)
{
DbHelper.RollbackTransaction();
BaseExceptionManager.LogException(DbHelper, UserInfo, ex);
throw;
}
return(result);
}
/// <summary>
/// 获取主键
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="name">查询的参数</param>
/// <param name="value">参数值</param>
/// <returns>影响行数</returns>
public string GetId(BaseUserInfo userInfo, string name, object value)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
string returnValue = string.Empty;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseStaffManager staffManager = new BaseStaffManager(dbHelper);
returnValue = staffManager.GetId(new KeyValuePair <string, object>(name, value));
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="dbHelper">数据库连接</param>
/// <param name="userInfo">用户</param>
/// <param name="Exception">异常</param>
/// <returns>主键</returns>
public static string LogException(IDbHelper dbHelper, BaseUserInfo userInfo, Exception ex)
{
// 在控制台需要输出错误信息
Console.ForegroundColor = ConsoleColor.Red;
Console.Write(ex.InnerException);
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(string.Empty);
string returnValue = string.Empty;
// 系统里应该可以配置是否记录异常现象
if (!BaseSystemInfo.LogException)
{
return(returnValue);
}
// Windows系统异常中
if (BaseSystemInfo.EventLog)
{
if (!System.Diagnostics.EventLog.SourceExists(BaseSystemInfo.SoftName))
{
System.Diagnostics.EventLog.CreateEventSource(BaseSystemInfo.SoftName, BaseSystemInfo.SoftFullName);
}
System.Diagnostics.EventLog eventLog = new System.Diagnostics.EventLog();
eventLog.Source = BaseSystemInfo.SoftName;
eventLog.WriteEntry(ex.Message, EventLogEntryType.Error);
}
// 判断一下数据库是否打开状态，若数据库都没能打开，还记录啥错误，不是又抛出另一个错误了？
if (dbHelper != null && dbHelper.GetDbConnection() != null)
{
if (dbHelper.GetDbConnection().State == ConnectionState.Open)
{
BaseExceptionManager exceptionManager = new BaseExceptionManager(dbHelper, userInfo);
returnValue = exceptionManager.AddEntity(ex);
}
}
return(returnValue);
}
/// <summary>
/// 用户现在
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="onLineState">用户在线状态</param>
public void OnLine(BaseUserInfo userInfo, int onLineState = 1)
{
// 写入调试信息
#if (DEBUG)
// int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
// BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.LogOnService_OnLine, MethodBase.GetCurrentMethod());
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
userManager.OnLine(userInfo.Id, onLineState);
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}
}
// 写入调试信息
#if (DEBUG)
// BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart, ConsoleColor.Green);
#endif
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/// 测试权限用的
/////////////////////////////////////////////////////////////////////////////////////////////////////////
#region public string AddPermission(BaseUserInfo userInfo, string permissionCode)
/// <summary>
/// 添加操作权限
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="permissionCode">权限编号</param>
/// <returns>主键</returns>
public string AddPermission(BaseUserInfo userInfo, string permissionCode)
{
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
string returnValue = string.Empty;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BasePermissionItemManager permissionItemManager = new BasePermissionItemManager(dbHelper, userInfo);
string statusCode = string.Empty;
BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity();
permissionItemEntity.Code = permissionCode;
permissionItemEntity.Enabled = 1;
permissionItemEntity.AllowDelete = 1;
permissionItemEntity.AllowEdit = 1;
permissionItemEntity.IsScope = 0;
returnValue = permissionItemManager.Add(permissionItemEntity, out statusCode);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.MSG0091, MethodBase.GetCurrentMethod());
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}
}
return(returnValue);
}
/// <summary>
/// ProcessDb
/// </summary>
/// <param name="serviceInfo"></param>
/// <param name="processFun"></param>
/// <param name="dbType"></param>
/// <param name="inTransaction"></param>
private static void ProcessDbHelp(ServiceInfo serviceInfo, ProcessFun processFun, DbType dbType, bool inTransaction)
{
// 2016-02-14 吉日嘎拉 增加耗时记录功能
var stopwatch = new Stopwatch();
stopwatch.Start();
using (var dbHelper = DbHelperFactory.Create(GetDbType(dbType), GetDbConnection(dbType)))
{
try
{
// dbHelper.Open(GetDbConnection(dbType));
if (inTransaction)
{
// dbHelper.BeginTransaction();
}
processFun(dbHelper);
stopwatch.Stop();
serviceInfo.ElapsedTicks = stopwatch.ElapsedTicks;
AddLog(serviceInfo);
if (inTransaction)
{
// dbHelper.CommitTransaction();
}
}
catch (Exception ex)
{
if (inTransaction)
{
// dbHelper.RollbackTransaction();
}
BaseExceptionManager.LogException(dbHelper, serviceInfo.UserInfo, ex);
throw;
}
}
}
/// <summary>
/// 记录异常情况
/// </summary>
/// <param name="dbHelper">数据库连接</param>
/// <param name="userInfo">用户</param>
/// <param name="ex"></param>
/// <param name="url"></param>
/// <returns>主键</returns>
public static string LogException(IDbHelper dbHelper, BaseUserInfo userInfo, Exception ex, string url = null)
{
// 在控制台需要输出错误信息
#if (DEBUG)
Console.ForegroundColor = ConsoleColor.Red;
Console.Write(ex.InnerException);
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(string.Empty);
#endif
var result = string.Empty;
// 系统里应该可以配置是否记录异常现象
if (!BaseSystemInfo.LogException)
{
return(result);
}
// Windows系统异常中
if (BaseSystemInfo.EventLog)
{
if (!EventLog.SourceExists(BaseSystemInfo.SoftName))
{
EventLog.CreateEventSource(BaseSystemInfo.SoftName, BaseSystemInfo.SoftFullName);
}
var eventLog = new EventLog
{
Source = BaseSystemInfo.SoftName
};
eventLog.WriteEntry(ex.Message, EventLogEntryType.Error);
}
//判断一下数据库是否打开状态，若数据库都没能打开，还记录啥错误，不是又抛出另一个错误了？
var exceptionManager = new BaseExceptionManager(dbHelper, userInfo);
result = exceptionManager.AddEntity(ex, url);
return(result);
}
/// <summary>
/// 撤销角色权限
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="roleName">角色名</param>
/// <param name="permissionItemCode">权限编号</param>
/// <returns>主键</returns>
public int RevokeRolePermission(BaseUserInfo userInfo, string roleName, string permissionItemCode)
{
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
int returnValue = 0;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseRoleManager roleManager = new BaseRoleManager(dbHelper, userInfo);
string roleId = roleManager.GetId(new KeyValuePair <string, object>(BaseRoleEntity.FieldRealName, roleName));
BasePermissionItemManager permissionItemManager = new BasePermissionItemManager(dbHelper, userInfo);
string permissionItemId = permissionItemManager.GetId(new KeyValuePair <string, object>(BasePermissionItemEntity.FieldCode, permissionItemCode));
if (!String.IsNullOrEmpty(roleId) && !String.IsNullOrEmpty(permissionItemId))
{
BaseRolePermissionManager rolePermissionManager = new BaseRolePermissionManager(dbHelper, userInfo);
returnValue = rolePermissionManager.Revoke(roleId, permissionItemId);
}
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}
}
return(returnValue);
}
/// <summary>
/// 分页查询
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="recordCount">记录数</param>
/// <param name="pageNo">当前页</param>
/// <param name="pageSize">每页显示</param>
/// <param name="condition">条件</param>
/// <param name="dbParameters">参数</param>
/// <param name="order">排序</param>
/// <returns>数据表</returns>
public DataTable GetDataTableByPage(BaseUserInfo userInfo, out int recordCount, int pageNo, int pageSize, string condition, List <KeyValuePair <string, object> > dbParameters, string order = null)
{
var myRecordCount = 0;
var dt = new DataTable(BaseExceptionEntity.CurrentTableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
if (SecretUtil.IsSqlSafe(condition))
{
var exceptionManager = new BaseExceptionManager(dbHelper, userInfo);
dt = exceptionManager.GetDataTableByPage(out myRecordCount, pageNo, pageSize, condition, dbHelper.MakeParameters(dbParameters), order);
dt.TableName = BaseExceptionEntity.CurrentTableName;
}
else
{
// 记录注入日志
LogUtil.WriteLog("userInfo:" + userInfo.Serialize() + " " + condition, "SqlSafe");
}
});
recordCount = myRecordCount;
return(dt);
}
/// <summary>
/// 自由审批退回
/// </summary>
/// <param name="workFlowManager">流程控制管理器</param>
/// <param name="workFlowAuditInfo">流程信息</param>
/// <returns>影响行数</returns>
public int FreeAuditReject(IWorkFlowManager workFlowManager, BaseWorkFlowAuditInfo workFlowAuditInfo)
{
// 返回值
int result = 0;
// 这里用锁的机制，提高并发控制能力
lock (WorkFlowCurrentLock)
{
try
{
// 开始事务
this.DbHelper.BeginTransaction();
BaseWorkFlowStepEntity workFlowStepEntity = new BaseWorkFlowStepEntity();
if (!string.IsNullOrEmpty(workFlowAuditInfo.ActivityId))
{
workFlowStepEntity.ActivityId = int.Parse(workFlowAuditInfo.ActivityId);
workFlowStepEntity.ActivityCode = workFlowAuditInfo.ActivityCode;
workFlowStepEntity.ActivityFullName = workFlowAuditInfo.ActivityFullName;
}
// 是否提交给用户审批
if (!string.IsNullOrEmpty(workFlowAuditInfo.ToUserId))
{
workFlowStepEntity.AuditUserId = workFlowAuditInfo.ToUserId;
workFlowStepEntity.AuditUserRealName = BaseUserManager.GetRealNameByCache(workFlowAuditInfo.ToUserId);
}
// 是否提交给部门审批
if (!string.IsNullOrEmpty(workFlowAuditInfo.ToDepartmentId))
{
workFlowStepEntity.AuditDepartmentId = workFlowAuditInfo.ToDepartmentId;
workFlowStepEntity.AuditDepartmentName = BaseOrganizeManager.GetNameByCache(workFlowAuditInfo.ToDepartmentId);
}
// 是否提交给角色审批
if (!string.IsNullOrEmpty(workFlowAuditInfo.ToRoleId))
{
workFlowStepEntity.AuditRoleId = workFlowAuditInfo.ToRoleId;
workFlowStepEntity.AuditRoleRealName = BaseRoleManager.GetRealNameByCache(this.UserInfo.SystemCode, workFlowAuditInfo.ToRoleId);
}
// 获取排序码
workFlowStepEntity.SortCode = int.Parse(new BaseSequenceManager().Increment("WorkFlow", 10000000));
// 进行更新操作
result = this.StepAuditReject(workFlowAuditInfo.Id, workFlowAuditInfo.AuditIdea, workFlowStepEntity);
if (result == 0)
{
// 数据可能被删除
this.StatusCode = Status.ErrorDeleted.ToString();
}
BaseWorkFlowCurrentEntity workFlowCurrentEntity = this.GetObject(workFlowAuditInfo.Id);
// 发送提醒信息
if (workFlowManager != null)
{
if (!string.IsNullOrEmpty(workFlowStepEntity.AuditUserId))
{
workFlowStepEntity.AuditDepartmentId = null;
workFlowStepEntity.AuditRoleId = null;
}
workFlowManager.OnAutoAuditReject(workFlowCurrentEntity);
workFlowManager.SendRemindMessage(workFlowCurrentEntity, AuditStatus.AuditReject, new string[] { workFlowCurrentEntity.CreateUserId, workFlowStepEntity.AuditUserId }, workFlowStepEntity.AuditDepartmentId, workFlowStepEntity.AuditRoleId);
}
this.StatusMessage = this.GetStateMessage(this.StatusCode);
this.DbHelper.CommitTransaction();
}
catch (Exception ex)
{
this.DbHelper.RollbackTransaction();
BaseExceptionManager.LogException(dbHelper, this.UserInfo, ex);
this.StatusCode = Status.Error.ToString();
// throw;
}
finally
{
this.DbHelper.Close();
}
return(result);
}
}
/// <summary>
/// 发送文件
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="fileName">文件名</param>
/// <param name="file">文件内容</param>
/// <param name="toUserId">发送给谁主键</param>
/// <returns>文件主键</returns>
public string Send(BaseUserInfo userInfo, string fileName, byte[] file, string toUserId)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
string returnValue = string.Empty;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseFolderEntity folderEntity = new BaseFolderEntity();
BaseFolderManager folderManager = new BaseFolderManager(dbHelper, userInfo);
// 检查相应的系统必备文件夹
folderManager.FolderCheck();
BaseUserEntity userEntity = new BaseUserManager(dbHelper, userInfo).GetEntity(toUserId);
if (!string.IsNullOrEmpty(userEntity.Id))
{
// 04:判断发送者的空间是否存在？
// 05:判断已收文件夹是否存在？
if (!folderManager.Exists(userEntity.Id.ToString()))
{
folderEntity.FolderName = userEntity.RealName + AppMessage.FileService_File;
folderEntity.ParentId = "UserSpace";
folderEntity.Id = userEntity.Id.ToString();
folderEntity.Enabled = 1;
folderEntity.DeletionStateCode = 0;
folderManager.AddEntity(folderEntity);
}
// 06:判断来自谁的文件夹是否存在？
// 07:判断发给谁的文件夹是否存在？
if (!folderManager.Exists(toUserId + "_Receive"))
{
folderEntity.FolderName = AppMessage.FileService_ReceiveFile;
folderEntity.ParentId = toUserId;
folderEntity.Id = toUserId + "_Receive";
folderEntity.Enabled = 1;
folderEntity.DeletionStateCode = 0;
folderManager.AddEntity(folderEntity);
}
if (!folderManager.Exists(userInfo.Id + "_Send_" + toUserId))
{
folderEntity.FolderName = userEntity.RealName + "(" + userEntity.UserName + ")";
folderEntity.ParentId = userInfo.Id + "_Send";
folderEntity.Id = userInfo.Id + "_Send_" + toUserId;
folderEntity.Enabled = 1;
folderEntity.DeletionStateCode = 0;
folderManager.AddEntity(folderEntity);
}
if (!folderManager.Exists(toUserId + "_Receive_" + userInfo.Id))
{
folderEntity.FolderName = userInfo.RealName + "(" + userInfo.UserName + ")";
folderEntity.ParentId = toUserId + "_Receive";
folderEntity.Id = toUserId + "_Receive_" + userInfo.Id;
folderEntity.Enabled = 1;
folderEntity.DeletionStateCode = 0;
folderManager.AddEntity(folderEntity);
}
// 08:已发送文件夹多一个文件。
// 09:已接收文件夹多一个文件。
BaseFileEntity fileEntity = new BaseFileEntity();
fileEntity.FileName = fileName;
fileEntity.Contents = file;
fileEntity.Enabled = 1;
fileEntity.ReadCount = 0;
fileEntity.FolderId = userInfo.Id + "_Send_" + toUserId;
// 把修改人显示出来
fileEntity.ModifiedBy = userInfo.RealName;
fileEntity.ModifiedUserId = userInfo.Id;
fileEntity.ModifiedOn = DateTime.Now;
BaseFileManager fileManager = new BaseFileManager(dbHelper, userInfo);
fileManager.AddEntity(fileEntity);
fileEntity.FolderId = toUserId + "_Receive_" + userInfo.Id;
returnValue = fileManager.AddEntity(fileEntity);
// string webHostUrl = BaseSystemInfo.WebHostUrl;
// if (string.IsNullOrEmpty(webHostUrl))
// {
// webHostUrl = "WebHostUrl";
// }
// 10:应该还发一个短信提醒一下才对。
BaseMessageEntity messageEntity = new BaseMessageEntity();
messageEntity.Id = Guid.NewGuid().ToString();
messageEntity.CategoryCode = MessageCategory.Send.ToString();
messageEntity.FunctionCode = MessageFunction.Message.ToString();
messageEntity.ObjectId = returnValue;
messageEntity.ReceiverId = toUserId;
// target=\"_blank\"
messageEntity.Contents = AppMessage.FileService_SendFileFrom + " <a href={WebHostUrl}Download.aspx?Id=" + returnValue + ">" + fileName + "</a>" + AppMessage.FileService_CheckReceiveFile;
messageEntity.IsNew = (int)MessageStateCode.New;
messageEntity.ReadCount = 0;
messageEntity.DeletionStateCode = 0;
messageEntity.Enabled = 1;
BaseMessageManager messageManager = new BaseMessageManager(dbHelper, userInfo);
returnValue = messageManager.Add(messageEntity);
}
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="workFlowManager">流程控制管理器</param>
/// <param name="workFlowAuditInfo">流程信息</param>
/// <returns>主键</returns>
public string FreeAuditStatr(IWorkFlowManager workFlowManager, BaseWorkFlowAuditInfo workFlowAuditInfo)
{
// 当工作流开始启动，进入流程审批
try
{
// 开始事务
this.DbHelper.BeginTransaction();
if (workFlowManager != null)
{
workFlowManager.BeforeAutoStatr(workFlowAuditInfo);
}
workFlowAuditInfo.AuditStatus = AuditStatus.StartAudit.ToString();
workFlowAuditInfo.AuditStatusName = AuditStatus.StartAudit.ToDescription();
workFlowAuditInfo.Description = "申请登记";
workFlowAuditInfo.Id = this.StepAuditStatr(workFlowAuditInfo);
BaseWorkFlowCurrentEntity workFlowCurrentEntity = this.GetObject(workFlowAuditInfo.Id);
// 获取当前处于什么状态
// 如果还是开始审批状态的话，允许他再次提交把原来的覆盖掉
// if (workFlowCurrentEntity.AuditStatus == AuditStatus.AuditReject.ToString())
// {
// 更新
// this.UpdataAuditStatr(workFlowCurrentEntity.Id, categoryCode, categoryFullName, objectId, objectFullName, auditIdea, workFlowStepEntity);
// 发送提醒信息，若发给指定的某个人了，就不发给部门的提示信息了
if (workFlowManager != null)
{
if (!string.IsNullOrEmpty(workFlowAuditInfo.ToUserId))
{
workFlowAuditInfo.ToDepartmentId = null;
workFlowAuditInfo.ToRoleId = null;
}
workFlowManager.SendRemindMessage(workFlowCurrentEntity, AuditStatus.StartAudit, new string[] { workFlowCurrentEntity.CreateUserId, workFlowAuditInfo.ToUserId }, workFlowAuditInfo.ToDepartmentId, workFlowAuditInfo.ToRoleId);
}
// 成功工作流后的处理
if (workFlowManager != null && !string.IsNullOrEmpty(workFlowAuditInfo.ObjectId))
{
workFlowManager.AfterAutoStatr(workFlowAuditInfo);
}
this.DbHelper.CommitTransaction();
// 运行成功
this.StatusCode = Status.OK.ToString();
this.StatusMessage = this.GetStateMessage(this.StatusCode);
}
catch (Exception ex)
{
this.DbHelper.RollbackTransaction();
BaseExceptionManager.LogException(dbHelper, this.UserInfo, ex);
this.StatusCode = Status.Error.ToString();
// throw;
}
finally
{
this.DbHelper.Close();
}
return(workFlowAuditInfo.Id);
}
