/// <summary>
/// 广播消息
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="message">消息内容</param>
/// <returns>主键</returns>
public int Broadcast(UserInfo userInfo, string message)
{
int returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, "广播消息");
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
string[] receiverIds = null;
var userManager = new PiUserManager(dbProvider, userInfo);
receiverIds = userManager.GetIds(new KeyValuePair <string, object>(PiUserTable.FieldEnabled, 1), new KeyValuePair <string, object>(PiUserTable.FieldDeleteMark, 0));
var messageManager = new CiMessageManager(dbProvider, userInfo);
var messageEntity = new CiMessageEntity
{
Id = BusinessLogic.NewGuid(),
FunctionCode = MessageFunction.Remind.ToString(),
MSGContent = message,
IsNew = 1,
ReadCount = 0,
Enabled = 1,
DeleteMark = 0
};
returnValue = messageManager.BatchSend(receiverIds, string.Empty, string.Empty, messageEntity, false);
});
return(returnValue);
}
/// <summary>
/// 发送系统提示消息
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="receiverId">接收者主键</param>
/// <param name="contents">内容</param>
/// <returns>主键</returns>
public string Remind(UserInfo userInfo, string receiverId, string contents)
{
string returnValue = string.Empty;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, "发送系统提示消息");
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var entity = new CiMessageEntity
{
Id = BusinessLogic.NewGuid(),
CategoryCode = MessageCategory.Receiver.ToString(),
FunctionCode = MessageFunction.Remind.ToString(),
ReceiverId = receiverId,
MSGContent = contents,
IsNew = (int)MessageStateCode.New,
ReadCount = 0,
DeleteMark = 0,
Enabled = 1
};
var manager = new CiMessageManager(dbProvider, userInfo);
returnValue = manager.Add(entity);
});
return(returnValue);
}
/// <summary>
/// 发送组消息
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="organizeId">组织机构主键</param>
/// <param name="roleId">角色主键</param>
/// <param name="contents">内容</param>
/// <returns></returns>
public string SendGroupMessage(UserInfo userInfo, string organizeId, string roleId, string contents)
{
int returnValue = 0;
var parameter = ParameterUtil.CreateWithLog(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var messageEntity = new CiMessageEntity
{
Id = BusinessLogic.NewGuid(),
CategoryCode = MessageCategory.Send.ToString(),
MSGContent = contents,
IsNew = (int)MessageStateCode.New,
ReadCount = 0,
DeleteMark = 0,
Enabled = 1
};
if (!string.IsNullOrEmpty(organizeId))
{
messageEntity.FunctionCode = MessageFunction.OrganizeMessage.ToString();
messageEntity.ObjectId = organizeId;
}
if (!string.IsNullOrEmpty(roleId))
{
messageEntity.FunctionCode = MessageFunction.RoleMessage.ToString();
messageEntity.ObjectId = roleId;
}
var messageManager = new CiMessageManager(dbProvider, userInfo);
returnValue = messageManager.BatchSend(string.Empty, organizeId, roleId, messageEntity, false);
});
return(returnValue.ToString());
}
/// <summary>
/// 取得实体
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="id">主键</param>
/// <returns>实体</returns>
public CiMessageEntity GetEntity(UserInfo userInfo, string id)
{
CiMessageEntity entity = null;
var parameter = ParameterUtil.CreateWithOutMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
entity = new CiMessageManager(dbProvider, userInfo).GetEntity(id);
});
return(entity);
}
/// <summary>
/// 批量逻辑删除消息
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <returns>影响的行数</returns>
public int SetDeleted(UserInfo userInfo, string[] ids)
{
var returnValue = 0;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.MessageService_SetDeleted);
ServiceUtil.ProcessRDIWriteDbWithTran(userInfo, parameter, dbProvider =>
{
returnValue = new CiMessageManager(dbProvider, userInfo).SetDeleted(ids);
});
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(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);
}
/// <summary>
/// 获取特定用户的新信息
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="receiverId">当前交互的用户</param>
/// <returns>数据表</returns>
public DataTable ReadFromReceiver(UserInfo userInfo, string receiverId)
{
var dataTable = new DataTable(CiMessageTable.TableName);
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.MessageService_ReadFromReceiver);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
var messageManager = new CiMessageManager(dbProvider, userInfo);
dataTable = messageManager.ReadFromReceiver(receiverId);
dataTable.TableName = CiMessageTable.TableName;
});
return(dataTable);
}
/// <summary>
/// 通过指定条件得到消息
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="whereConditional">指定条件表达式</param>
/// <param name="recordCount">记录数</param>
/// <param name="pageIndex">当前页</param>
/// <param name="pageSize">每页显示</param>
/// <param name="order">排序</param>
/// <returns>数据表</returns>
public DataTable GetMessagesByConditional(UserInfo userInfo, string whereConditional, out int recordCount, int pageIndex = 0, int pageSize = 20, string order = null)
{
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.MessageService_GetMessagesByConditional);
int myrecordCount = 0;
var dataTable = new DataTable(CiMessageTable.TableName);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, (dbProvider) =>
{
var messageManager = new CiMessageManager(dbProvider, userInfo);
dataTable = messageManager.GetMessagesByConditional(whereConditional, userInfo.IsAdministrator, out myrecordCount, pageIndex, pageSize, order);
dataTable.TableName = CiMessageTable.TableName;
});
recordCount = myrecordCount;
return(dataTable);
}
/// <summary>
/// 获取消息状态
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="onLineState">用户在线状态</param>
/// <param name="lastChekDate">最后检查日期</param>
/// <returns>消息状态数组</returns>
public string[] MessageChek(UserInfo userInfo, int onLineState, string lastChekDate)
{
string[] returnValue = null;
var parameter = ParameterUtil.CreateWithMessage(userInfo, MethodBase.GetCurrentMethod(), this.serviceName, RDIFrameworkMessage.MessageService_MessageChek);
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
// 设置为在线状态
var manager = new PiUserLogOnManager(dbProvider, userInfo);
manager.OnLine(userInfo.Id, onLineState);
// 读取信息状态
var messageManager = new CiMessageManager(dbProvider, userInfo);
returnValue = messageManager.MessageChek();
});
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>
/// <param name="userInfo">用户</param>
/// <param name="openId">单点登录标识</param>
/// <returns>数据表</returns>
public DataTable GetDTNew(UserInfo userInfo, out string openId)
{
var dataTable = new DataTable(CiMessageTable.TableName);
string myOpenId = userInfo.OpenId;
var parameter = ParameterUtil.CreateWithLog(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessRDIReadDb(userInfo, parameter, dbProvider =>
{
if (!SystemInfo.CheckOnLine)
{
var manager = new PiUserLogOnManager(dbProvider, userInfo);
myOpenId = manager.GetProperty(userInfo.Id, PiUserLogOnTable.FieldOpenId);
}
if (userInfo.OpenId.Equals(myOpenId))
{
var messageManager = new CiMessageManager(dbProvider, userInfo);
dataTable = messageManager.GetDTNew();
dataTable.TableName = CiMessageTable.TableName;
}
});
openId = myOpenId;
return(dataTable);
}
/// <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);
}
