public string AddReceiver(string contactId, string receiverId)
{
string returnValue = string.Empty;
// 需要判断是否存在
if (this.Exists(new KeyValuePair<string, object>(BaseContactDetailsEntity.FieldContactId,contactId)
, new KeyValuePair<string, object>(BaseContactDetailsEntity.FieldReceiverId, receiverId)
, new KeyValuePair<string, object>(BaseContactDetailsEntity.FieldCategory, "User")))
{
return string.Empty;
}
BaseUserManager userManager = new BaseUserManager(DbHelper, UserInfo);
BaseUserEntity useEntity = userManager.GetEntity(int.Parse(receiverId));
BaseContactDetailsEntity contactDetailsEntity = new BaseContactDetailsEntity();
// 这里一定要给个不可猜测的主键，为了提高安全性
contactDetailsEntity.Id = BaseBusinessLogic.NewGuid();
contactDetailsEntity.ContactId = contactId;
contactDetailsEntity.Category = "User";
contactDetailsEntity.ReceiverId = useEntity.Id.ToString();
contactDetailsEntity.ReceiverRealName = useEntity.RealName;
contactDetailsEntity.IsNew = 0;
contactDetailsEntity.Enabled = 1;
contactDetailsEntity.NewComment = 0;
returnValue = this.Add(contactDetailsEntity);
// 这里需要重新计算发送给了几个人，几个人已经阅读的功能
this.SetReadState(contactId);
return returnValue;
}
/// <summary>
/// 替换当前步骤中的人员
/// </summary>
/// <param name="oldUserId">原来的工号</param>
/// <param name="newUserId">新的工号</param>
/// <returns>影响行数</returns>
public int ReplaceUser(string oldUserId, string newUserId)
{
BaseUserManager userManager = new BaseUserManager(this.UserInfo);
BaseUserEntity newUserEntity = userManager.GetEntity(newUserId);
SQLBuilder sqlBuilder = new SQLBuilder(this.DbHelper);
sqlBuilder.BeginUpdate(this.CurrentTableName);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldAuditUserId, newUserEntity.Id);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldAuditUserCode, newUserEntity.Code);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldAuditUserRealName, newUserEntity.RealName);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldAuditDepartmentId, newUserEntity.DepartmentId);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldAuditDepartmentName, newUserEntity.DepartmentName);
sqlBuilder.SetWhere(BaseWorkFlowStepEntity.FieldAuditUserId, oldUserId, "OldUserId");
return sqlBuilder.EndUpdate();
}
/// <summary>
/// 获取用户实体
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="id">主键</param>
/// <returns>实体</returns>
public BaseUserEntity GetEntity(BaseUserInfo userInfo, string id)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
// 加强安全验证防止未授权匿名调用
#if (!DEBUG)
LogOnService.UserIsLogOn(userInfo);
#endif
BaseUserEntity userEntity = null;
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(UserCenterDbConnection);
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
userEntity = userManager.GetEntity(id);
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.UserService_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 userEntity;
}
/// <summary>
/// 下个流程发送给谁
/// </summary>
/// <param name="id">当前主键</param>
/// <returns>影响行数</returns>
private int StepAuditTransmit(string currentId, string workFlowCategory, string sendToId, string auditIdea)
{
BaseWorkFlowCurrentEntity workFlowCurrentEntity = this.GetEntity(currentId);
// 1.记录当前的审核时间、审核人信息
workFlowCurrentEntity.ToDepartmentId = this.UserInfo.DepartmentId;
workFlowCurrentEntity.ToDepartmentName = this.UserInfo.DepartmentName;
workFlowCurrentEntity.ToUserId = this.UserInfo.Id;
workFlowCurrentEntity.ToUserRealName = this.UserInfo.RealName;
workFlowCurrentEntity.AuditStatus = AuditStatus.Transmit.ToString();
workFlowCurrentEntity.AuditStatusName = AuditStatus.Transmit.ToDescription();
// 2.记录审核日志
this.AddHistory(workFlowCurrentEntity);
// 3.上一个审核结束了，新的审核又开始了，更新待审核情况
workFlowCurrentEntity.AuditUserId = this.UserInfo.Id;
workFlowCurrentEntity.AuditUserRealName = this.UserInfo.RealName;
workFlowCurrentEntity.AuditDate = DateTime.Now;
workFlowCurrentEntity.AuditIdea = auditIdea;
// 是否提交给部门审批
if (workFlowCategory.Equals("ByOrganize"))
{
BaseOrganizeManager organizeManager = new BaseOrganizeManager(UserInfo);
BaseOrganizeEntity organizeEntity = organizeManager.GetEntity(sendToId);
// 设置审批部门主键
workFlowCurrentEntity.ToDepartmentId = sendToId;
// 设置审批部门名称
workFlowCurrentEntity.ToDepartmentName = organizeEntity.FullName;
}
// 是否提交给角色审批
if (workFlowCategory.Equals("ByRole"))
{
BaseRoleManager roleManger = new BaseRoleManager(this.UserInfo);
BaseRoleEntity roleEntity = roleManger.GetEntity(sendToId);
// 设置审批角色主键
workFlowCurrentEntity.ToRoleId = sendToId;
// 设置审批角色名称
workFlowCurrentEntity.ToRoleRealName = roleEntity.RealName;
}
// 是否提交给用户审批
if (workFlowCategory.Equals("ByUser"))
{
BaseUserManager userManager = new BaseUserManager(UserInfo);
BaseUserEntity userEntity = userManager.GetEntity(sendToId);
// 设置审批用户主键
workFlowCurrentEntity.ToUserId = sendToId;
// 设置审批用户名称
workFlowCurrentEntity.ToUserRealName = userEntity.RealName;
// TODO 用户的部门信息需要处理
if (!string.IsNullOrEmpty(userEntity.DepartmentId))
{
BaseOrganizeManager organizeManager = new BaseOrganizeManager(UserInfo);
BaseOrganizeEntity organizeEntity = organizeManager.GetEntity(userEntity.DepartmentId);
workFlowCurrentEntity.ToDepartmentId = userEntity.DepartmentId;
workFlowCurrentEntity.ToDepartmentName = organizeEntity.FullName;
}
}
workFlowCurrentEntity.AuditStatus = AuditStatus.WaitForAudit.ToString();
workFlowCurrentEntity.AuditStatusName = AuditStatus.WaitForAudit.ToDescription();
// 当前审核人的信息写入当前工作流
workFlowCurrentEntity.Enabled = 0;
workFlowCurrentEntity.DeletionStateCode = 0;
return this.UpdateEntity(workFlowCurrentEntity);
}
/// <summary>
/// 员工关联用户
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="staffId">员工主键</param>
/// <param name="userId">用户主键</param>
/// <returns>影响行数</returns>
public int SetStaffUser(BaseUserInfo userInfo, string staffId, string userId)
{
// 写入调试信息
#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);
if (string.IsNullOrEmpty(userId))
{
returnValue = staffManager.SetProperty(staffId, new KeyValuePair<string, object>(BaseStaffEntity.FieldUserId, userId));
}
else
{
// 一个用户只能帮定到一个帐户上，检查是否已经绑定过这个用户了。
string[] staffIds = staffManager.GetIds(new KeyValuePair<string, object>(BaseStaffEntity.FieldUserId, userId), new KeyValuePair<string, object>(BaseStaffEntity.FieldDeletionStateCode, 0));
if (staffIds == null || staffIds.Length == 0)
{
returnValue = staffManager.SetProperty(staffId, new KeyValuePair<string, object>(BaseStaffEntity.FieldUserId, userId));
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
BaseUserEntity userEntity = userManager.GetEntity(userId);
returnValue = staffManager.SetProperty(staffId, new KeyValuePair<string, object>(BaseStaffEntity.FieldUserName, userEntity.UserName));
}
}
BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.StaffService_SetStaffUser, 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="managerUserId">管理用户主键</param>
/// <param name="permissionItemCode">权限编号</param>
/// <returns>主键数组</returns>
public string[] GetUserIds(string managerUserId, string permissionItemCode)
{
string[] ids = this.GetTreeResourceScopeIds(managerUserId, BaseOrganizeEntity.TableName, permissionItemCode, true);
// 是否为仅本人
if (StringUtil.Exists(ids, ((int)PermissionScope.User).ToString()))
{
return new string[] { managerUserId };
}
string sqlQuery = this.GetUserIdsSql(managerUserId, permissionItemCode);
DataTable dataTable = DbHelper.Fill(sqlQuery);
// 这里应该考虑，当前用户的管理权限是，所在公司？所在部门？所以在工作组等情况
if (ids != null && ids.Length > 0)
{
BaseUserManager userManager = new BaseUserManager(this.DbHelper, this.UserInfo);
BaseUserEntity userEntity = userManager.GetEntity(managerUserId);
for (int i = 0; i < ids.Length; i++)
{
if (ids[i].Equals(((int)PermissionScope.User).ToString()))
{
ids[i] = userEntity.Id.ToString();
break;
}
}
}
// 这里列出只是有效地，没被删除的角色主键
if (ids != null && ids.Length > 0)
{
BaseUserManager userManager = new BaseUserManager(this.DbHelper, this.UserInfo);
List<KeyValuePair<string, object>> parameters = new List<KeyValuePair<string, object>>();
parameters.Add(new KeyValuePair<string, object>(BaseUserEntity.FieldId, ids));
parameters.Add(new KeyValuePair<string, object>(BaseUserEntity.FieldEnabled, 1));
parameters.Add(new KeyValuePair<string, object>(BaseUserEntity.FieldDeletionStateCode, 0));
string[] names = new string[] { BaseUserEntity.FieldId, BaseUserEntity.FieldEnabled, BaseUserEntity.FieldDeletionStateCode };
Object[] values = new Object[] { ids, 1, 0 };
ids = userManager.GetIds(parameters);
}
return ids;
}
/// <summary>
/// 审核退回详细步骤
/// </summary>
/// <param name="currentId">当前主键</param>
/// <param name="auditIdea">批示</param>
/// <param name="toUserId">发送给</param>
/// <param name="activityId">退回到指定步骤</param>
/// <returns>影响行数</returns>
private BaseWorkFlowCurrentEntity StepAuditReject(string currentId, string auditIdea, string toUserId = null, string activityId = null)
{
BaseWorkFlowCurrentEntity workFlowCurrentEntity = this.GetEntity(currentId);
// 1.记录审核时间、审核人
workFlowCurrentEntity.AuditUserId = this.UserInfo.Id;
workFlowCurrentEntity.AuditUserCode = this.UserInfo.Code;
workFlowCurrentEntity.AuditUserRealName = this.UserInfo.RealName;
workFlowCurrentEntity.AuditStatus = AuditStatus.AuditReject.ToString();
workFlowCurrentEntity.AuditStatusName = AuditStatus.AuditReject.ToDescription();
workFlowCurrentEntity.AuditDate = DateTime.Now;
workFlowCurrentEntity.AuditIdea = auditIdea;
// 2.记录日志
this.AddHistory(workFlowCurrentEntity);
// 3.更新待审核情况，流程已经结束了
workFlowCurrentEntity.ActivityId = null;
if (!string.IsNullOrEmpty(activityId))
{
workFlowCurrentEntity.ActivityId = int.Parse(activityId);
BaseWorkFlowActivityManager workFlowActivityManager = new BaseWorkFlowActivityManager(this.DbHelper, this.UserInfo);
BaseWorkFlowActivityEntity workFlowActivityEntity = workFlowActivityManager.GetEntity(activityId);
workFlowCurrentEntity.SortCode = workFlowActivityEntity.SortCode;
workFlowCurrentEntity.ToUserId = workFlowActivityEntity.AuditUserId;
workFlowCurrentEntity.ToUserRealName = workFlowActivityEntity.AuditUserRealName;
workFlowCurrentEntity.ToDepartmentId = workFlowActivityEntity.AuditDepartmentId;
workFlowCurrentEntity.ToDepartmentName = workFlowActivityEntity.AuditDepartmentName;
workFlowCurrentEntity.ToRoleId = workFlowActivityEntity.AuditRoleId;
workFlowCurrentEntity.ToRoleRealName = workFlowActivityEntity.AuditRoleRealName;
}
else
{
if (!string.IsNullOrEmpty(toUserId))
{
BaseUserManager userManager = new BaseUserManager(UserInfo);
BaseUserEntity userEntity = userManager.GetEntity(toUserId);
workFlowCurrentEntity.ToUserId = userEntity.Id;
workFlowCurrentEntity.ToUserRealName = userEntity.RealName;
workFlowCurrentEntity.ToDepartmentId = userEntity.DepartmentId;
workFlowCurrentEntity.ToDepartmentName = userEntity.DepartmentName;
}
//workFlowCurrentEntity.SortCode = null;
}
workFlowCurrentEntity.SendDate = DateTime.Now;
workFlowCurrentEntity.Enabled = 0;
// 4.生成审核结束的记录
this.UpdateEntity(workFlowCurrentEntity);
return workFlowCurrentEntity;
}
/// <summary>
/// 按员工的修改信息，把用户信息进行修改
/// </summary>
/// <param name="staffId">员工主键</param>
/// <returns>影响行数</returns>
public int UpdateUser(string staffId)
{
DataTable dataTable = this.GetDataTable(BaseStaffEntity.FieldId, staffId);
BaseStaffEntity staffEntity = new BaseStaffEntity(dataTable);
if (staffEntity.UserId > 0)
{
// 员工信息改变时，用户信息也跟着改变。
BaseUserManager userManager = new BaseUserManager(DbHelper, UserInfo);
BaseUserEntity userEntity = userManager.GetEntity(staffEntity.UserId);
// userEntity.Company = staffEntity.CompanyName;
// userEntity.Department = staffEntity.DepartmentName;
// userEntity.Workgroup = staffEntity.WorkgroupName;
userEntity.UserName = staffEntity.UserName;
userEntity.RealName = staffEntity.RealName;
userEntity.Code = staffEntity.Code;
userEntity.Email = staffEntity.Email;
userEntity.Enabled = staffEntity.Enabled;
// userEntity.Duty = staffEntity.DutyName;
// userEntity.Title = staffEntity.TitleName;
userEntity.Gender = staffEntity.Gender;
userEntity.Birthday = staffEntity.Birthday;
userEntity.Mobile = staffEntity.Mobile;
}
return 0;
}
/// <summary>
/// 发送给自己一份
/// </summary>
/// <param name="contactId">联络单主键</param>
public string Send(string contactId)
{
BaseUserManager userManager = new BaseUserManager(DbHelper, UserInfo);
BaseUserEntity useEntity = useEntity = userManager.GetEntity(int.Parse(UserInfo.Id));
BaseContactDetailsEntity contactDetailsEntity = new BaseContactDetailsEntity();
// 这里一定要给个不可猜测的主键，为了提高安全性
contactDetailsEntity.Id = BaseBusinessLogic.NewGuid();
contactDetailsEntity.ContactId = contactId;
contactDetailsEntity.Category = "User";
contactDetailsEntity.ReceiverId = useEntity.Id.ToString();
contactDetailsEntity.ReceiverRealName = useEntity.RealName;
contactDetailsEntity.IsNew = 0;
contactDetailsEntity.Enabled = 1;
contactDetailsEntity.NewComment = 0;
BaseContactDetailsManager contactDetailsManager = new BaseContactDetailsManager(DbHelper, UserInfo);
return contactDetailsManager.Add(contactDetailsEntity, false);
}
/// <summary>
/// 发送联络单
/// </summary>
/// <param name="contactId">联络单主键</param>
/// <param name="receiverIds">接收者</param>
/// <returns>影响行数</returns>
public int Send(string contactId, string[] receiverIds)
{
int returnValue = 0;
// 是否给自己发过这封邮件
bool findSend = false;
BaseContactDetailsManager contactDetailsManager = new BaseContactDetailsManager(DbHelper, UserInfo);
BaseUserManager userManager = new BaseUserManager(DbHelper, UserInfo);
BaseUserEntity useEntity = null;
BaseContactDetailsEntity contactDetailsEntity = null;
for (int i = 0; i < receiverIds.Length; i++)
{
useEntity = userManager.GetEntity(int.Parse(receiverIds[i]));
// 是有效的用户，而且是未必删除的用户才发邮件
if (useEntity.Enabled == 1 && useEntity.DeletionStateCode == 0)
{
contactDetailsEntity = new BaseContactDetailsEntity();
// 这里一定要给个不可猜测的主键，为了提高安全性
contactDetailsEntity.Id = BaseBusinessLogic.NewGuid();
contactDetailsEntity.ContactId = contactId;
contactDetailsEntity.Category = "User";
contactDetailsEntity.ReceiverId = useEntity.Id.ToString();
contactDetailsEntity.ReceiverRealName = useEntity.RealName;
contactDetailsEntity.IsNew = 1;
contactDetailsEntity.Enabled = 1;
contactDetailsEntity.NewComment = 0;
contactDetailsManager.Add(contactDetailsEntity, false);
}
// 若已经有发过，就不用再判断了
if (!findSend)
{
if (UserInfo.Id.Equals(receiverIds[i]))
{
findSend = true;
}
}
returnValue++;
}
// 没有给自己发过
if (!findSend)
{
// 发送给自己一份
this.Send(contactId);
returnValue++;
}
// 设置总共发送了几个人
this.SetProperty(new KeyValuePair<string, object>(BaseContactEntity.FieldId, contactId), new KeyValuePair<string, object>(BaseContactEntity.FieldSendCount, receiverIds.Length.ToString()));
return returnValue;
}
private int UpdataAuditStatr(string id, string categoryCode, string categoryFullName, string objectId, string objectFullName, string auditIdea, BaseWorkFlowStepEntity workFlowStepEntity)
{
BaseWorkFlowCurrentEntity workFlowCurrentEntity = this.GetEntity(id);
workFlowCurrentEntity.CategoryCode = categoryCode;
workFlowCurrentEntity.CategoryFullName = categoryFullName;
workFlowCurrentEntity.ObjectId = objectId;
workFlowCurrentEntity.ObjectFullName = objectFullName;
workFlowCurrentEntity.WorkFlowId = workFlowStepEntity.WorkFlowId;
workFlowCurrentEntity.ActivityId = workFlowStepEntity.Id;
workFlowCurrentEntity.SendDate = DateTime.Now;
workFlowCurrentEntity.AuditDate = DateTime.Now;
workFlowCurrentEntity.AuditStatus = AuditStatus.StartAudit.ToString();
workFlowCurrentEntity.AuditStatusName = AuditStatus.StartAudit.ToDescription();
// 是否提交给组织机构审批
if (!string.IsNullOrEmpty(workFlowStepEntity.AuditDepartmentId))
{
workFlowCurrentEntity.ToDepartmentId = workFlowStepEntity.AuditDepartmentId;
workFlowCurrentEntity.ToDepartmentName = workFlowStepEntity.AuditDepartmentName;
}
// 是否提交给角色审批
if (!string.IsNullOrEmpty(workFlowStepEntity.AuditRoleId))
{
workFlowCurrentEntity.ToDepartmentId = workFlowStepEntity.AuditRoleId;
workFlowCurrentEntity.ToDepartmentName = workFlowStepEntity.AuditRoleRealName;
}
// 是否提交给用户审批
if (!string.IsNullOrEmpty(workFlowStepEntity.AuditUserId))
{
BaseUserManager userManager = new BaseUserManager(UserInfo);
BaseUserEntity userEntity = userManager.GetEntity(workFlowStepEntity.AuditUserId);
workFlowCurrentEntity.ToUserId = workFlowStepEntity.AuditUserId;
workFlowCurrentEntity.ToUserRealName = userEntity.RealName;
// TODO 用户的部门信息需要处理
if (!string.IsNullOrEmpty(userEntity.DepartmentId))
{
BaseOrganizeManager organizeManager = new BaseOrganizeManager(UserInfo);
BaseOrganizeEntity organizeEntity = organizeManager.GetEntity(userEntity.DepartmentId);
workFlowCurrentEntity.ToDepartmentId = userEntity.DepartmentId;
workFlowCurrentEntity.ToDepartmentName = organizeEntity.FullName;
}
}
// 当前审核人的信息写入当前工作流
// workFlowCurrentEntity.AuditUserId = this.UserInfo.Id;
// workFlowCurrentEntity.AuditUserCode = this.UserInfo.Code;
// workFlowCurrentEntity.AuditUserRealName = this.UserInfo.RealName;
workFlowCurrentEntity.AuditIdea = auditIdea;
workFlowCurrentEntity.AuditDate = DateTime.Now;
return this.UpdateEntity(workFlowCurrentEntity);
}
/// <summary>
/// 添加短信，可以发给多个人
/// </summary>
/// <param name="messageEntity">实体</param>
/// <param name="receiverIds">接收者ID组</param>
/// <returns>影响行数</returns>
public int Send(BaseMessageEntity messageEntity, string[] receiverIds, bool saveSend = true)
{
BaseUserManager userManager = new BaseUserManager(DbHelper, UserInfo);
// 每发一条短信，数据库中需要记录两条记录，他们的CreateUserId都为创建者ID。
// 接收者多人的话，不要重复设置创建人的记录了，即对发送者来说，只要记录一条记录就够了
int returnValue = 0;
messageEntity.CategoryCode = MessageCategory.Receiver.ToString();
messageEntity.IsNew = (int)MessageStateCode.New;
messageEntity.IPAddress = UserInfo.IPAddress;
messageEntity.ParentId = null;
messageEntity.DeletionStateCode = 0;
messageEntity.Enabled = 1;
returnValue++;
BaseUserEntity 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 && !string.IsNullOrEmpty(userEntity.Id))
{
messageEntity.ReceiverRealName = userEntity.RealName;
// 发给了哪个部门的人，意义不大，是来自哪个部门的人，意义更大一些
// messageEntity.DepartmentId = userEntity.DepartmentId;
// messageEntity.DepartmentName = userEntity.DepartmentName;
}
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.DeletionStateCode = 0;
messageEntity.Enabled = 0;
this.Add(messageEntity, false, false);
}
returnValue++;
}
return returnValue;
}
/// <summary>
/// 转发给别人看
/// </summary>
/// <param name="contactId">内部联络单主键</param>
/// <param name="receiverIds">送给</param>
/// <returns>影响行数</returns>
public int AddReceivers(string contactId, string[] receiverIds)
{
int returnValue = 0;
BaseUserManager userManager = new BaseUserManager(DbHelper, UserInfo);
BaseUserEntity useEntity = null;
for (int i = 0; i < receiverIds.Length; i++)
{
if (!this.Exists(new KeyValuePair<string, object>(BaseContactDetailsEntity.FieldContactId, contactId)
, new KeyValuePair<string, object>(BaseContactDetailsEntity.FieldReceiverId, receiverIds[i])))
{
useEntity = userManager.GetEntity(receiverIds[i]);
// 是有效的用户，而且是未必删除的用户才发邮件
if (useEntity.Enabled == 1 && useEntity.DeletionStateCode == 0)
{
this.AddReceiver(useEntity, contactId, receiverIds[i]);
returnValue++;
}
}
}
// 这里需要重新计算发送给了几个人，几个人已经阅读的功能
this.SetReadState(contactId);
return returnValue;
}