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="userInfo">用户</param>
/// <param name="staffId">员工主键</param>
/// <param name="userId">用户主键</param>
/// <returns>影响行数</returns>
public int SetStaffUser(BaseUserInfo userInfo, string staffId, string userId)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseStaffManager(dbHelper, userInfo);
if (ValidateUtil.IsInt(userId))
{
result = manager.SetProperty(staffId, new KeyValuePair <string, object>(BaseStaffEntity.FieldUserId, userId));
}
else
{
// 一个用户只能帮定到一个帐户上，检查是否已经绑定过这个用户了。
var staffIds = manager.GetIds(new KeyValuePair <string, object>(BaseStaffEntity.FieldUserId, userId), new KeyValuePair <string, object>(BaseStaffEntity.FieldDeleted, 0));
if (staffIds == null || staffIds.Length == 0)
{
result = manager.SetProperty(staffId, new KeyValuePair <string, object>(BaseStaffEntity.FieldUserId, userId));
var userManager = new BaseUserManager(dbHelper, userInfo);
var userEntity = userManager.GetEntity(userId);
result = manager.SetProperty(staffId, new KeyValuePair <string, object>(BaseStaffEntity.FieldUserName, userEntity.UserName));
}
}
});
return(result);
}
/// <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="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);
}
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="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(BaseWorkFlowCurrentEntity.FieldToUserId, newUserEntity.Id);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldToUserRealName, newUserEntity.RealName);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldToDepartmentId, newUserEntity.DepartmentId);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldToDepartmentName, newUserEntity.DepartmentName);
sqlBuilder.SetWhere(BaseWorkFlowCurrentEntity.FieldToUserId, oldUserId, "OldUserId");
return(sqlBuilder.EndUpdate());
}
/// <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);
}
/// <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="id">主键</param>
/// <returns>用户信息</returns>
public static BaseUserEntity SetCache(string id)
{
BaseUserEntity result = null;
var manager = new BaseUserManager();
result = manager.GetEntity(id);
if (result != null)
{
SetCache(result);
}
return(result);
}
/// <summary>
/// 获取用户实体
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="id">主键</param>
/// <returns>实体</returns>
public BaseUserEntity GetEntity(BaseUserInfo userInfo, string id)
{
BaseUserEntity entity = null;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var userManager = new BaseUserManager(dbHelper, userInfo);
// 判断是否已经登录的用户？
if (userManager.UserIsLogon(userInfo))
{
entity = userManager.GetEntity(id);
}
});
return(entity);
}
/// <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="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="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);
}
/// <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="taskId">任务标识</param>
/// <param name="userInfo">用户信息</param>
/// <param name="userName">用户名</param>
/// <param name="email">电子邮件</param>
/// <returns>成功</returns>
public bool GetPasswordByEmail(string taskId, BaseUserInfo userInfo, string userName, string email)
{
var result = false;
var manager = new BaseUserContactManager();
var parameters = new List <KeyValuePair <string, object> >();
if (!string.IsNullOrEmpty(email))
{
parameters.Add(new KeyValuePair <string, object>(BaseUserContactEntity.FieldEmail, email));
}
var id = manager.GetId(parameters);
if (!string.IsNullOrEmpty(id))
{
var userManager = new BaseUserManager();
var userNameOk = true;
var userEntity = userManager.GetEntity(id);
if (!string.IsNullOrEmpty(userName))
{
if (!string.IsNullOrEmpty(userEntity.UserName) && !userEntity.UserName.Equals(userName, StringComparison.Ordinal))
{
userNameOk = false;
userInfo = null;
}
}
if (userNameOk)
{
userInfo = userManager.ConvertToUserInfo(userEntity);
}
}
if (!string.IsNullOrEmpty(id))
{
var userPassword = string.Empty;
if (BaseSystemInfo.CheckPasswordStrength)
{
userPassword = RandomUtil.GetString(8).ToLower();
}
else
{
userPassword = RandomUtil.GetString(8).ToLower();
// Random random = new System.Random();
// userPassword = random.Next(100000, 999999).ToString();
}
// 邮件内容
var smtpClient = new SmtpClient(BaseSystemInfo.MailServer)
{
UseDefaultCredentials = false,
Credentials = new NetworkCredential(BaseSystemInfo.MailUserName, BaseSystemInfo.MailPassword),
// 指定如何处理待发的邮件
DeliveryMethod = SmtpDeliveryMethod.Network
};
var mailTitle = BaseSystemInfo.SoftFullName + "忘记密码";
var mailBody = "您的新密码为：" + userPassword + " " + Environment.NewLine
+ "<br/> " + Environment.NewLine + BaseSystemInfo.SoftFullName + "访问地址： http://www.wangcaisoft.com/";
// 读取模板文件
var file = BaseSystemInfo.StartupPath + "\\Forgot.Mail.txt";
if (System.IO.File.Exists(file))
{
mailBody = System.IO.File.ReadAllText(file, Encoding.UTF8);
mailBody = mailBody.Replace("{Realname}", userInfo.RealName);
mailBody = mailBody.Replace("{UserPassword}", userPassword);
}
// 发送邮件
var mailMessage = new MailMessage(BaseSystemInfo.MailUserName, email, mailTitle, mailBody)
{
BodyEncoding = Encoding.Default,
IsBodyHtml = true
};
smtpClient.Send(mailMessage);
var userManager = new BaseUserManager(userInfo);
userManager.SetPassword(userInfo.UserId, userPassword);
userManager.GetStateMessage();
if (userManager.StatusCode == Status.SetPasswordOk.ToString())
{
result = true;
}
else
{
result = false;
}
}
return(result);
}
