/// <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="cIMESSAGEEntity">实体</param>
private void SetEntity(SQLBuilder sqlBuilder, CiMessageEntity cIMESSAGEEntity)
{
sqlBuilder.SetValue(CiMessageTable.FieldParentId, cIMESSAGEEntity.ParentId);
sqlBuilder.SetValue(CiMessageTable.FieldFunctionCode, cIMESSAGEEntity.FunctionCode);
sqlBuilder.SetValue(CiMessageTable.FieldCategoryCode, cIMESSAGEEntity.CategoryCode);
sqlBuilder.SetValue(CiMessageTable.FieldObjectId, cIMESSAGEEntity.ObjectId);
sqlBuilder.SetValue(CiMessageTable.FieldTitle, cIMESSAGEEntity.Title);
sqlBuilder.SetValue(CiMessageTable.FieldMSGContent, cIMESSAGEEntity.MSGContent);
sqlBuilder.SetValue(CiMessageTable.FieldReceiverId, cIMESSAGEEntity.ReceiverId);
sqlBuilder.SetValue(CiMessageTable.FieldReceiverRealName, cIMESSAGEEntity.ReceiverRealName);
sqlBuilder.SetValue(CiMessageTable.FieldIsNew, cIMESSAGEEntity.IsNew);
sqlBuilder.SetValue(CiMessageTable.FieldReadCount, cIMESSAGEEntity.ReadCount);
if (DBProvider.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetValue(CiMessageTable.FieldReadDate, cIMESSAGEEntity.ReadDate != null ? BusinessLogic.GetOracleDateFormat(System.DateTime.Parse(cIMESSAGEEntity.ReadDate.ToString()), "yyyy-mm-dd hh24:mi:ss") : cIMESSAGEEntity.ReadDate);
}
else
{
sqlBuilder.SetValue(CiMessageTable.FieldReadDate, cIMESSAGEEntity.ReadDate);
}
sqlBuilder.SetValue(CiMessageTable.FieldTargetURL, cIMESSAGEEntity.TargetURL);
sqlBuilder.SetValue(CiMessageTable.FieldIPAddress, cIMESSAGEEntity.IPAddress);
sqlBuilder.SetValue(CiMessageTable.FieldDeleteMark, cIMESSAGEEntity.DeleteMark);
sqlBuilder.SetValue(CiMessageTable.FieldEnabled, cIMESSAGEEntity.Enabled);
sqlBuilder.SetValue(CiMessageTable.FieldDescription, cIMESSAGEEntity.Description);
sqlBuilder.SetValue(CiMessageTable.FieldSortCode, cIMESSAGEEntity.SortCode);
}
/// <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="messageEntity">实体</param>
/// <param name="id">短信主键</param>
/// <returns>影响的条数</returns>
private int OnRead(CiMessageEntity messageEntity, string id)
{
int returnValue = 0;
// 针对“已发送”的情况
if (messageEntity.ReceiverId == UserInfo.Id)
{
// 针对“删除的信息”的情况
if (messageEntity.IsNew == (int)MessageStateCode.New)
{
SQLBuilder sqlBuilder = new SQLBuilder(this.DBProvider);
sqlBuilder.BeginUpdate(this.CurrentTableName);
sqlBuilder.SetValue(CiMessageTable.FieldIsNew, ((int)MessageStateCode.Old).ToString());
sqlBuilder.SetDBNow(CiMessageTable.FieldReadDate);
sqlBuilder.SetWhere(CiMessageTable.FieldId, id);
sqlBuilder.EndUpdate();
}
}
// 增加阅读次数
messageEntity.ReadCount++;
this.SetProperty(id, CiMessageTable.FieldReadCount, messageEntity.ReadCount.ToString());
returnValue++;
return(returnValue);
}
/// <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="id">短信ID</param>
/// <returns>数据权限</returns>
public DataTable Read(string id)
{
// 这里需要改进一下，运行一个高性能的sql语句就可以了，效率会高一些
DataTable dataTable = this.GetDTById(id);
CiMessageEntity messageEntity = BaseEntity.Create <CiMessageEntity>(dataTable);
this.OnRead(messageEntity, id);
dataTable = this.GetDTById(id);
return(dataTable);
}
/// <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="messageEntity">实体</param>
/// <param name="receiverIds">接收者ID组</param>
/// <returns>影响行数</returns>
public int Send(CiMessageEntity messageEntity, string[] receiverIds, bool saveSend = true)
{
PiUserManager userManager = new PiUserManager(DBProvider, UserInfo);
// 每发一条短信，数据库中需要记录两条记录，他们的CreateUserId都为创建者ID。
// 接收者多人的话，不要重复设置创建人的记录了，即对发送者来说，只要记录一条记录就够了
int returnValue = 0;
messageEntity.CategoryCode = MessageCategory.Receiver.ToString();
messageEntity.IsNew = (int)MessageStateCode.New;
messageEntity.IPAddress = UserInfo.IPAddress;
messageEntity.ParentId = null;
messageEntity.DeleteMark = 0;
messageEntity.Enabled = 1;
returnValue++;
PiUserEntity userEntity = null;
for (int i = 0; i < receiverIds.Length; i++)
{
messageEntity.ParentId = null;
messageEntity.Id = Guid.NewGuid().ToString();
messageEntity.CategoryCode = MessageCategory.Receiver.ToString();
messageEntity.ReceiverId = receiverIds[i];
userEntity = userManager.GetEntity(receiverIds[i]);
if (userEntity != null && userEntity.Id != null)
{
messageEntity.ReceiverRealName = userEntity.RealName;
}
messageEntity.Enabled = 1;
messageEntity.IsNew = 1;
if (messageEntity.ReceiverId.Equals(UserInfo.Id))
{
messageEntity.IsNew = (int)MessageStateCode.Old;
}
// 接收信息
string parentId = this.Add(messageEntity, false, false);
if (saveSend)
{
// 已发送信息
messageEntity.Id = Guid.NewGuid().ToString();
messageEntity.ParentId = parentId;
messageEntity.CategoryCode = MessageCategory.Send.ToString();
messageEntity.DeleteMark = 0;
messageEntity.Enabled = 0;
this.Add(messageEntity, false, false);
}
returnValue++;
}
return(returnValue);
}
/// <summary>
/// 更新实体
/// </summary>
/// <param name="cIMESSAGEEntity">实体</param>
public int UpdateEntity(CiMessageEntity cIMESSAGEEntity)
{
SQLBuilder sqlBuilder = new SQLBuilder(DBProvider);
sqlBuilder.BeginUpdate(this.CurrentTableName);
this.SetEntity(sqlBuilder, cIMESSAGEEntity);
if (UserInfo != null)
{
sqlBuilder.SetValue(CiMessageTable.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(CiMessageTable.FieldModifiedOn);
sqlBuilder.SetWhere(CiMessageTable.FieldId, cIMESSAGEEntity.Id);
return(sqlBuilder.EndUpdate());
}
public int BatchSend(string[] receiverIds, string organizeId, string roleId, CiMessageEntity messageEntity, bool saveSend = true)
{
string[] organizeIds = null;
string[] roleIds = null;
if (!string.IsNullOrEmpty(organizeId))
{
organizeIds = new string[] { organizeId };
}
if (!string.IsNullOrEmpty(roleId))
{
roleIds = new string[] { roleId };
}
return(BatchSend(receiverIds, organizeIds, roleIds, messageEntity, saveSend));
}
/// <summary>
/// 按部门群发短信
/// </summary>
/// <param name="messageEntity">实体</param>
/// <param name="organizeId">部门主键</param>
/// <returns>影响行数</returns>
public int Send(CiMessageEntity messageEntity, string organizeId, bool saveSend = true)
{
int returnValue = 0;
int i = 0;
PiUserManager userManager = new PiUserManager(DBProvider, UserInfo);
DataTable dataTable = userManager.GetChildrenUsers(organizeId);
string[] receiverIds = new string[dataTable.Rows.Count];
foreach (DataRow dataRow in dataTable.Rows)
{
receiverIds[i++] = dataRow[CiMessageTable.FieldId].ToString();
}
returnValue = this.Send(messageEntity, receiverIds, saveSend);
return(returnValue);
}
/// <summary>
/// 添加用户
/// </summary>
/// <param name="dbProvider">数据库连接</param>
/// <param name="userInfo">用户信息</param>
/// <param name="userEntity">用户实体</param>
/// <param name="statusCode">状态码</param>
/// <param name="statusMessage">状态信息</param>
/// <returns>主键</returns>
public string AddUser(IDbProvider dbProvider, UserInfo userInfo, PiUserEntity userEntity, out string statusCode, out string statusMessage)
{
string returnValue = string.Empty;
var userManager = new PiUserManager(dbProvider, userInfo);
returnValue = userManager.Add(userEntity, out statusCode);
statusMessage = userManager.GetStateMessage(statusCode);
LogManager.Instance.Add(dbProvider, userInfo, this.serviceName, RDIFrameworkMessage.UserService_AddUser, MethodBase.GetCurrentMethod());
// 自己不用给自己发提示信息，这个提示信息是为了提高工作效率的，还是需要审核通过的，否则垃圾信息太多了
if (userEntity.Enabled == 0 && statusCode.Equals(StatusCode.OKAdd.ToString()))
{
// 不是系统管理员添加
if (!userInfo.IsAdministrator)
{
// 给超级管理员群组发信息
var roleManager = new PiRoleManager(dbProvider, userInfo);
string[] roleIds = roleManager.GetIds(PiRoleTable.FieldCode, "Administrators", PiRoleTable.FieldId);
string[] userIds = userManager.GetIds(PiUserTable.FieldCode, "Administrator", PiUserTable.FieldId);
// 发送请求审核的信息
var messageEntity = new CiMessageEntity
{
Id = BusinessLogic.NewGuid(),
FunctionCode = MessageFunction.WaitForAudit.ToString(),
ReceiverId = DefaultRole.Administrator.ToString(),
MSGContent = userInfo.RealName + "(" + userInfo.IPAddress + ")" + RDIFrameworkMessage.UserService_Application + userEntity.RealName + RDIFrameworkMessage.UserService_Check,
IsNew = 1,
ReadCount = 0,
Enabled = 1,
DeleteMark = 0
};
var messageManager = new CiMessageManager(dbProvider, userInfo);
messageManager.BatchSend(userIds, null, roleIds, messageEntity, false);
}
}
return(returnValue);
}
/// <summary>
/// 检查信息状态
/// </summary>
/// <returns>信息状态数组</returns>
public string[] MessageChek()
{
string[] returnValue = new string[6];
// 0.新信息的个数
int messageCount = this.GetNewCount();
returnValue[0] = messageCount.ToString();
if (messageCount > 0)
{
CiMessageEntity messageEntity = this.GetNewOne();
DateTime lastChekDate = DateTime.MinValue;
if (messageEntity.CreateOn != null)
{
// 1.最后检查时间
lastChekDate = Convert.ToDateTime(messageEntity.CreateOn);
returnValue[1] = lastChekDate.ToString(SystemInfo.DateTimeFormat);
}
returnValue[2] = messageEntity.CreateUserId; // 2.最新消息的发出者
returnValue[3] = messageEntity.CreateBy; // 3.最新消息的发出者名称
returnValue[4] = messageEntity.Id; // 4.最新消息的主键
returnValue[5] = messageEntity.MSGContent; // 5.最新信息的内容
}
return(returnValue);
}
/// <summary>
/// 批量发送消息
/// </summary>
/// <param name="receiverIds">接收者主键组</param>
/// <param name="organizeIds">组织机构主键组</param>
/// <param name="roleIds">角色主键组</param>
/// <param name="messageEntity">实体</param>
/// <returns>影响行数</returns>
public int BatchSend(string[] receiverIds, string[] organizeIds, string[] roleIds, CiMessageEntity messageEntity, bool saveSend = true)
{
PiUserManager userManager = new PiUserManager(DBProvider, UserInfo);
receiverIds = userManager.GetUserIds(receiverIds, organizeIds, roleIds);
return(this.Send(messageEntity, receiverIds, saveSend));
}
/// <summary>
/// 添加一条短信，只能发给一个人，在数据库中加入两条记录
/// </summary>
/// <param name="messageEntity">添加对象</param>
/// <returns>影响行数</returns>
public int Send(CiMessageEntity messageEntity, bool saveSend = true)
{
string[] receiverIds = new string[1];
receiverIds[0] = messageEntity.ReceiverId.ToString();
return(this.Send(messageEntity, receiverIds, saveSend));
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="cIMESSAGEEntity">实体</param>
public string AddEntity(CiMessageEntity cIMESSAGEEntity)
{
string sequence = string.Empty;
this.Identity = false;
if (cIMESSAGEEntity.SortCode == null || cIMESSAGEEntity.SortCode == 0)
{
CiSequenceManager sequenceManager = new CiSequenceManager(DBProvider, this.Identity);
sequence = sequenceManager.GetSequence(this.CurrentTableName);
cIMESSAGEEntity.SortCode = int.Parse(sequence);
}
SQLBuilder sqlBuilder = new SQLBuilder(DBProvider, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, CiMessageTable.FieldId);
if (!this.Identity)
{
if (string.IsNullOrEmpty(cIMESSAGEEntity.Id))
{
sequence = BusinessLogic.NewGuid();
cIMESSAGEEntity.Id = sequence;
}
sqlBuilder.SetValue(CiMessageTable.FieldId, cIMESSAGEEntity.Id);
}
else
{
if (!this.ReturnId && (DBProvider.CurrentDbType == CurrentDbType.Oracle || DBProvider.CurrentDbType == CurrentDbType.DB2))
{
if (DBProvider.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(CiMessageTable.FieldId, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
}
if (DBProvider.CurrentDbType == CurrentDbType.DB2)
{
sqlBuilder.SetFormula(CiMessageTable.FieldId, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
}
}
else
{
if (this.Identity && (DBProvider.CurrentDbType == CurrentDbType.Oracle || DBProvider.CurrentDbType == CurrentDbType.DB2))
{
if (string.IsNullOrEmpty(cIMESSAGEEntity.Id))
{
if (string.IsNullOrEmpty(sequence))
{
CiSequenceManager sequenceManager = new CiSequenceManager(DBProvider, this.Identity);
sequence = sequenceManager.GetSequence(this.CurrentTableName);
}
cIMESSAGEEntity.Id = sequence;
}
sqlBuilder.SetValue(CiMessageTable.FieldId, cIMESSAGEEntity.Id);
}
}
}
this.SetEntity(sqlBuilder, cIMESSAGEEntity);
if (UserInfo != null)
{
sqlBuilder.SetValue(CiMessageTable.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(CiMessageTable.FieldCreateBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(CiMessageTable.FieldCreateOn);
if (UserInfo != null)
{
sqlBuilder.SetValue(CiMessageTable.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(CiMessageTable.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(CiMessageTable.FieldModifiedOn);
if (this.Identity && (DBProvider.CurrentDbType == CurrentDbType.SqlServer || DBProvider.CurrentDbType == CurrentDbType.Access))
{
sequence = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
return(sequence);
}
/// <summary>
/// 更新
/// </summary>
/// <param name="cIMESSAGEEntity">实体</param>
public int Update(CiMessageEntity cIMESSAGEEntity)
{
return(this.UpdateEntity(cIMESSAGEEntity));
}
/// <summary>
/// 添加
/// </summary>
/// <param name="cIMESSAGEEntity">实体</param>
/// <param name="identity">自增量方式</param>
/// <param name="returnId">返回主键</param>
/// <returns>主键</returns>
public string Add(CiMessageEntity cIMESSAGEEntity, bool identity, bool returnId)
{
this.Identity = identity;
this.ReturnId = returnId;
return(this.AddEntity(cIMESSAGEEntity));
}
/// <summary>
/// 添加
/// </summary>
/// <param name="cIMESSAGEEntity">实体</param>
/// <returns>主键</returns>
public string Add(CiMessageEntity cIMESSAGEEntity)
{
return(this.AddEntity(cIMESSAGEEntity));
}
/// <summary>
/// 指定处理人
/// </summary>
/// <param name="userId">用户Id</param>
/// <param name="workFlowId">流程模板Id</param>
/// <param name="workTaskId">任务模板Id</param>
/// <param name="workFlowInstanceId">流程实例Id</param>
/// <param name="workTaskInstanceId">任务实例Id</param>
/// <param name="operParam">处理者参数</param>
/// <returns>是否成功</returns>
public bool AssignUser(string userId, string workFlowId, string workTaskId, string workFlowInstanceId, string workTaskInstanceId, OperParameter operParam)
{
if (string.IsNullOrEmpty(operParam.OperContent))
{
return(false);
}
switch (operParam.OperRule)
{
case "1":
{
//创建处理人实例
var operInsEntity = new OperatorInstanceEntity()
{
OperatorInsId = BusinessLogic.NewGuid(),
WorkFlowId = workFlowId,
WorkTaskId = workTaskId,
WorkFlowInsId = workFlowInstanceId,
WorkTaskInsId = workTaskInstanceId, //此时是新任务Id
UserId = "",
OperRealtion = operParam.OperRelation,
OperContent = operParam.OperContent,
OperContentText = operParam.OperContenText,
OperType = operParam.OperType//此处保留原来的处理类型
};
string successCode = new OperatorInstanceManager(this.DBProvider).Create(operInsEntity);
//给处理者发送信息
if (!string.IsNullOrEmpty(successCode) && successCode.Length > 0)
{
var messageEntity = new CiMessageEntity
{
Id = BusinessLogic.NewGuid(),
FunctionCode = MessageFunction.Remind.ToString(),
ReceiverId = DefaultRole.Administrator.ToString(),
Title = "业务流程消息",
MSGContent = "你有一待办任务，请到未认领任务界面认领。",
IsNew = 1,
ReadCount = 0,
Enabled = 1,
DeleteMark = 0
};
var messageManager = new CiMessageManager(DbFactoryProvider.GetProvider(SystemInfo.RDIFrameworkDbType, SystemInfo.RDIFrameworkDbConectionString), this.UserInfo);
messageManager.BatchSend(operInsEntity.OperContent, null, null, messageEntity, false);
}
if ((userId == operParam.OperContent) && (operParam.IsJumpSelf)) //处理者是提交人，自动处理
{
var wfrun = new WorkFlowRuntime();
wfrun.Run(userId, operInsEntity.OperatorInsId, "提交");
}
}
break;
case "2":
{
//创建任务实例
var newTaskId = BusinessLogic.NewGuid();//新任务实例Id
var workTaskInsEntity = new WorkTaskInstanceEntity()
{
WorkFlowId = workFlowId,
WorkTaskId = workTaskId,
WorkFlowInsId = workFlowInstanceId,
WorkTaskInsId = newTaskId,
PreviousTaskId = workTaskInstanceId, //此时是当前任务Id
TaskInsCaption = new WorkTaskManager(this.DBProvider).GetTaskCaption(workTaskId),
Status = "1",
};
new WorkTaskInstanceManager(this.DBProvider).Create(workTaskInsEntity);
//创建处理人实例
var operInsEntity = new OperatorInstanceEntity()
{
OperatorInsId = BusinessLogic.NewGuid(),
WorkFlowId = workFlowId,
WorkTaskId = workTaskId,
WorkFlowInsId = workFlowInstanceId,
WorkTaskInsId = newTaskId,
UserId = "",
OperRealtion = operParam.OperRelation,
OperContent = operParam.OperContent,
OperContentText = operParam.OperContenText,
OperType = 3,//此处修改为指定处理人
};
string successCode = new OperatorInstanceManager(this.DBProvider).Create(operInsEntity);
//给处理者发送信息
if (!string.IsNullOrEmpty(successCode) && successCode.Length > 0)
{
var messageEntity = new CiMessageEntity
{
Id = BusinessLogic.NewGuid(),
FunctionCode = MessageFunction.Remind.ToString(),
ReceiverId = DefaultRole.Administrator.ToString(),
Title = "业务流程消息",
MSGContent = "你有一待办任务，请到未认领任务界面认领。",
IsNew = 1,
ReadCount = 0,
Enabled = 1,
DeleteMark = 0
};
var messageManager = new CiMessageManager(DbFactoryProvider.GetProvider(SystemInfo.RDIFrameworkDbType, SystemInfo.RDIFrameworkDbConectionString), this.UserInfo);
messageManager.BatchSend(operInsEntity.OperContent, null, null, messageEntity, false);
}
if ((userId == operParam.OperContent) && (operParam.IsJumpSelf)) //处理者是提交人，自动处理
{
var wfrun = new WorkFlowRuntime();
wfrun.Run(userId, operInsEntity.OperatorInsId, "提交");
}
}
break;
}
return(true);
}
/// <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(UserInfo userInfo, string[] receiverIds, string[] organizeIds, string[] roleIds, CiMessageEntity messageEntity)
{
int returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.MessageService_BatchSend);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var messageManager = new CiMessageManager(dbProvider, userInfo);
returnValue = messageManager.BatchSend(receiverIds, organizeIds, roleIds, messageEntity, true);
});
return(returnValue);
}