/// <summary>
///
/// </summary>
/// <param name="list"></param>
/// <param name="write_enum"></param>
private void WriteInDB(List<SMSModel_QueryReceive> list,ref PMS.Model.Enum.WriteInDb_Enum write_enum)
{
IS_SMSRecord_CurrentBLL smsRecord_CurrentBLL = new PMS.BLL.S_SMSRecord_CurrentBLL();
//思路
/*尽量减少反复连接数据库的操作
先从list中提取msgid不同的对象
*/
//1 查出不同的msgid集合（IEnmuerable）
var list_distinct_msgid = from s in list.Distinct(new PMS.Model.EqualCompare.SMSModel_QueryReceive_Compare())
select s.msgId;
write_enum = PMS.Model.Enum.WriteInDb_Enum.ok;
//2 遍历
foreach (var item in list_distinct_msgid)
{
//2.1 取出对应msgid对应的集合
var list_temp = (from s in list
where s.msgId == item
select s).ToList();
//2.2批量写入
try
{
smsRecord_CurrentBLL.SaveReceieveMsg(list_temp,item);
Console.WriteLine("写入成功{0}个人其对应msgid为{1}",list_temp.Count(),item);
}
catch (Exception ex)
{
write_enum =PMS.Model.Enum.WriteInDb_Enum.error;
}
}
}
public static PMS.Model.DTO.Core.Master.Department MapDepartmentDTOToMasterDepartmentDTO(PMS.Model.DTO.Core.Department departmentDTO)
{
PMS.Model.DTO.Core.Master.Department dto = new PMS.Model.DTO.Core.Master.Department()
{
Id = Convert.ToInt32(departmentDTO.DepartmentId)
};
return dto;
}
public void AddRole(PMS.Model.DTO.Core.Security.UserRole role)
{
if (role != null)
{
if (Lib.Utility.Common.IsNullOrEmptyList(lst_roles))
{
lst_roles = new List<PMS.Model.DTO.Core.Security.UserRole>();
}
lst_roles.Add(role);
}
}
public static PMS.Model.DTO.Master.Action MapActionEntityToDTO(PMS.Model.Context.PMS_MST_ACTION entity)
{
PMS.Model.DTO.Master.Action obj_dto = new DTO.Master.Action()
{
Id = entity.ID,
Name = entity.NAME,
Description = entity.DESCRIPTION,
Active = entity.ACTIVE
};
return obj_dto;
}
public void AddOwner(PMS.Model.DTO.Core.Task.Owner owner)
{
if (owner != null)
{
if (Lib.Utility.Common.IsNullOrEmptyList(lst_owners))
{
lst_owners = new List<PMS.Model.DTO.Core.Task.Owner>();
}
lst_owners.Add(owner);
}
}
/// <summary>
/// 执行发送作业（延时或立刻）
/// 需要先注册发送方法
/// </summary>
/// <param name="model">发送对象</param>
/// <param name="response">响应</param>
public void JobsRun(PMS.Model.CombineModel.SendAndMessage_Model model, out SMSModel_Receive receive)
{
receive = new SMSModel_Receive();
if (DoSendJobs != null)
{
DoSendJobs(model,out receive);
}
else
{
//response = new PMS.Model.Message.BaseResponse() { Message = "未绑定方法", Success = false };
}
}
public static PMS.Model.DTO.Core.Master.Department MapDepartmentEntityToDTO(PMS.Model.Context.MST_DEPARTMENT entity)
{
PMS.Model.DTO.Core.Master.Department obj_dto = new DTO.Core.Master.Department()
{
Id = entity.ID,
Name = entity.NAME,
Abbreviation = entity.ABBREVIATION,
Description = entity.DESCRIPTION,
Active = entity.ACTIVE
};
return obj_dto;
}
public static PMS.Model.Context.PMS_APPRAISAL_CAREER_DEVELOPMENT MapAppraisalCareerDevelopmentDTOToEntity(PMS.Model.DTO.Appraisal.CareerDevelopment dto)
{
PMS.Model.Context.PMS_APPRAISAL_CAREER_DEVELOPMENT obj_entity = new Context.PMS_APPRAISAL_CAREER_DEVELOPMENT()
{
ID = dto.Id,
APPRAISAL_ID = dto.Appraisal == null ? (int?)null : dto.Appraisal.Id,
//SECTION_ID = dto.Section == null ? (int?)null : dto.Section.Id,
CAREER_PLAN = dto.CareerPlans,
SHORT_TERM_GOALS = dto.ShortTermGoals,
LEARNING_PLAN = dto.LearningPlans
};
return obj_entity;
}
public static PMS.Model.Context.PMS_APPRAISAL_CAREER_DEVELOPMENT_COMMENT MapAppraisalCareerDevelopmentCommentDTOToEntity(PMS.Model.DTO.Appraisal.CareerDevelopmentComment dto)
{
PMS.Model.Context.PMS_APPRAISAL_CAREER_DEVELOPMENT_COMMENT obj_entity = new Context.PMS_APPRAISAL_CAREER_DEVELOPMENT_COMMENT()
{
ID = dto.Id,
ITEM_ID = dto.AppraisalCareerDevelopment == null ? (int?)null : dto.AppraisalCareerDevelopment.Id,
COMMENT = dto.Comments,
COMMENTED_BY_ID = dto.Commentor == null ? (int?)null : dto.Commentor.Id,
COMMENTED_TIMESTAMP = dto.CommentedTimestamp,
FORM_SAVE_ONLY = dto.FormSaveOnly
};
return obj_entity;
}
public static void InsertListModel(SMSModel_QueryReceive item, ref List<SMSModel_QueryReceive> list, ref PMS.Model.Enum.MatchCondition_Enum state)
{
if(item != null)
{
//将拥有符合条件的msgid的item存入list
list.Add(item);
state = PMS.Model.Enum.MatchCondition_Enum.conform;
}
else
{
}
}
public static PMS.Model.DTO.Appraisal.CareerDevelopmentComment MapAppraisalCareerDevelopmentCommentEntityToDTO(PMS.Model.Context.PMS_APPRAISAL_CAREER_DEVELOPMENT_COMMENT entity)
{
PMS.Model.DTO.Appraisal.CareerDevelopmentComment obj_dto = new PMS.Model.DTO.Appraisal.CareerDevelopmentComment()
{
Id = entity.ID,
ItemId = entity.ITEM_ID,
Comments = entity.COMMENT,
Commentor = CoreMapper.MapEmployeeEntityToDTO(entity.EMPLOYEE),
CommentedTimestamp = entity.COMMENTED_TIMESTAMP,
FormSaveOnly = entity.FORM_SAVE_ONLY
};
obj_dto.AppraisalCareerDevelopment = entity.PMS_APPRAISAL_CAREER_DEVELOPMENT == null ? null : MapAppraisalCareerDevelopmentEntityToDTO(entity.PMS_APPRAISAL_CAREER_DEVELOPMENT, false);
return obj_dto;
}
/// <summary>
/// 执行添加作业方法
/// 1 先向数据库中的JobInfo表中写入相应数据（手动赋予JobState属性为running）
/// 2 执行Quartz的新添作业方法
/// 3 之前未注意到：
/// 需要获取发送信息的内容，以及查询时保存的一些参数（先实现发送信息的内容）
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ContentResult DoAddJobInfo(PMS.Model.J_JobInfo model)
{
//***此时传入的model中已经包含了uid的值了
if (model.NextRunTime <= DateTime.MinValue)
{
model.NextRunTime = DateTime.Now;
}
if (model.EndRunTime <= DateTime.MinValue)
{
model.EndRunTime = DateTime.MaxValue;
}
// model.EndRunTime = model.StartRunTime.AddMinutes(1);
model.CreateTime = DateTime.Now;
//创建时手动添加该作业的状态
model.JobState = Convert.ToInt32(PMS.Model.Enum.JobState_Enum.running);
model.Interval_quartz = Common.Config.QueryQuartzConfigHelper.GetIntervalQueryAgain();
//注意需要修改此bll中实现的方法，不仅创建J_JobInfo还要创建与UserInfo的关联关系
//***注意此时的顺序是先向数据库中的JobInfo表写入再执行Quartz操作（向数据库中写入后model中会有JID）——但应该先执行Quartz的添加作业操作****
//1 将状态写入数据库
var response = jobInfoBLL.AddJobInfo(model);
return this.ToResponse(response);
//11月20日 备注掉
#region
//if (jobInfoBLL.AddJobInfo(model).Success)
//{
// //注意：
// //在创建之后此model中的JID已经有值了，可以直接获取该JID的值
// //2 操作Quartz操作类
// //PMS.Model.SMSModel.SMSModel_Send data_temp = new PMS.Model.SMSModel.SMSModel_Send();
// //jobService.AddScheduleJob(model, data_temp);
// return Content("ok");
//}
//else
//{
// return Content("error");
//}
#endregion
}
public static PMS.Model.DTO.Core.Employee MapEmployeeEntityToDTO(PMS.Model.Context.EMPLOYEE entity)
{
PMS.Model.DTO.Core.Employee obj_dto = new DTO.Core.Employee()
{
Id = entity.ID,
FirstName = entity.FIRST_NAME,
LastName = entity.LAST_NAME,
PreferredName = entity.PREFERRED_NAME,
DomainId = entity.DOMAIN_ID,
Department = entity.DEPARTMENT == null ? null : MapEmployeeDepartmentToDTO(entity.DEPARTMENT),
ACRGrade = entity.MST_ACR_GRADE == null ? null : MapGradeEntityToDTO(entity.MST_ACR_GRADE),
EmploymentType = entity.MST_EMPLOYMENT_TYPE == null ? null : MapEmploymentTypeEntityToDTO(entity.MST_EMPLOYMENT_TYPE),
Active = entity.ACTIVE,
OfficeEmailAddress = entity.OFFICE_EMAIL_ADDRESS,
ContactNo =entity.OFFICE_TEL_NUMBER,
SeatLocation=entity.OFFICE_SEAT_LOCATION,
DateOfDeparture = entity.DATE_OF_DEPARTURE,
DateOfHire = entity.DATE_OF_HIRE,
SMPEmploeeId=entity.SENIOR_MANAGEMENT_TEAM_MEMBER_ID
};
return obj_dto;
}
/// <summary>
/// 短信发送
/// </summary>
/// <param name="smsdata"></param>
/// <returns></returns>
public bool SendMsg(PMS.Model.CombineModel.SendAndMessage_Model model, out /*PMS.Model.Message.BaseResponse response*/SMSModel_Receive receive)
{
SendJobManagement jobManagement = new SendJobManagement();
//判断是否开启定时发送功能
if (model.Model_Message.isTiming)
{
//绑定定时发送功能
//使用作业调度
jobManagement.DoSendJobs += SendMsgbyDelayed;
}
else
{
//绑定立刻发送功能
jobManagement.DoSendJobs += SendMsgbyNow;
}
//不管具体绑定的是哪个方法，调用该发送方法
//SMSModel_Receive receive = new SMSModel_Receive();
jobManagement.JobsRun(model,out receive);
//response = new PMS.Model.Message.BaseResponse() { Success = true };
return false;
}
/// <summary>
/// 步骤一 获取传入的群组及部门获取对应联系人
///获取要删除的联系人id
///从联系人集合中去除要删除的联系人获得最终要发送的联系人
/// </summary>
/// <param name="model"></param>
/// <param name="delegateGetPersonList"></param>
/// <returns></returns>
public List<string> GetFinalPersonPhoneList(PMS.Model.ViewModel.ViewModel_Message model,DelegateSMS.delegate_GetPersonListByGroupDepartment delegateGetPersonList)
{
//List<P_PersonInfo> delegate_GetPersonListByGroupDepartment(string dids, string gids, out int rowCount, int pageSize = -1, int pageIndex = -1);
// Func<string,string,int,int,int,List<P_PersonInfo>>
//Func<string,string,>
//Action<string,string>
//Action<int, int, string> act = (a, b, c) =>
// {
// };
//重新梳理并做抽象
/*步骤一：
获取传入的群组及部门获取对应联系人
获取要删除的联系人id
从联系人集合中去除要删除的联系人获得最终要发送的联系人
*/
//1 获取要去除的 联系人id 数组
var ids = model.PersonId_Int;
int count = 0;
string dids_str = null;
string gids_str = null;
if (model.GroupIds == null)
{
gids_str = "";
}
if (model.DepartmentIds == null)
{
dids_str = "";
}
if (model.GroupIds != null)
{
foreach (var item in model.GroupIds)
{
gids_str += item.ToString() + ",";
}
}
if (model.DepartmentIds != null)
{
foreach (var item in model.DepartmentIds)
{
dids_str += item.ToString() + ",";
}
}
//2 根据传入的群组及部门id获取对应的联系人
List<P_PersonInfo> list_person = delegateGetPersonList(dids_str, gids_str, out count);
//3 去除不需要的联系人，获得最终联系人集合
list_person = (from p in list_person
where !ids.Contains(p.PID)
select p).ToList();
//4 获取联系人集合中的电话生成电话集合
List<string> list_phones = new List<string>();
list_person.ForEach(p => list_phones.Add(p.PhoneNum.ToString()));
return list_phones;
}
/// <summary>
/// 在发送短信之后执行
/// 步骤五：
/// 创建短信内容至数据库
/// 创建发送记录至数据库
/// （此处应放在SMSFactory.SendMsg或写在JobInstance中的SendJob.Exceuted）
/// </summary>
/// <param name="model"></param>
/// <param name="receive"></param>
/// <param name="list_phones"></param>
/// <param name="redis_list_id">redis中保存的list的key</param>
/// <param name="redis_expirationDate">redis中保存集合的过期时间（默认72小时）</param>
/// <returns></returns>
public bool AfterSend(PMS.Model.ViewModel.ViewModel_Message model, SMSModel_Receive receive, List<string> list_phones,string redis_list_id,int redis_expirationDate=72)
{
//5 将发送的短信以及提交响应存入SMSContent
var mid = model.SMSMissionID;
var uid = model.UID;
bool isSaveMsgOk = smsContentBLL.SaveMsg(receive, model.Content, mid, uid);
//在current表中存入发送信息，在query之前，表中的StatusCode默认为98，DescContent默认为"暂时未收到查询回执"
//7月28日 注意此处已修改方法为：CreateReceieveMsg！！！
if (!smsRecord_CurrentBLL.CreateReceieveMsg(receive.msgid, list_phones))
{
return false;
}
/*步骤六：
写入redis缓存中
（此处应放在SMSFactory.SendMsg中或写在JobInstance中的SendJob.Exceuted）
*/
ListReidsHelper<PMS.Model.QueryModel.Redis_SMSContent> redisListhelper = new ListReidsHelper<PMS.Model.QueryModel.Redis_SMSContent>(redis_list_id);
StringRedisHelper redisStrhelper = new StringRedisHelper();
redisStrhelper.Set(receive.msgid, "1", DateTime.Now.AddMinutes(redis_expirationDate));
return true;
}
/// <summary>
/// 步骤二 获取添加的临时联系人
/// 向数据库中写入这些临时联系人
/// </summary>
/// <param name="model"></param>
/// <param name="personBLL"></param>
/// <param name="groupBLL"></param>
/// <returns></returns>
public List<string> AddAndGetTempPersons(PMS.Model.ViewModel.ViewModel_Message model,IP_PersonInfoBLL personBLL,IP_GroupBLL groupBLL)
{
/*步骤二：
获取添加的临时联系人
向数据库中写入这些临时联系人
*/
//1.2 获取临时联系人的电话数组
var phoneNums = model.PhoneNum_Str;
//1.3 调用personBLL中的添加联系人方法，将临时联系人写入数据库（qu）
string PName_Temp = "临时联系人";
//1.4 目前默认只添加到全部联系人群组中
int groupID_AllContacts = groupBLL.GetListBy(a => a.GroupName.Equals("全部联系人")).FirstOrDefault().GID;
List<int> groupIds = new List<int>();
groupIds.Add(groupID_AllContacts);
//1.5 循环写入数据库
bool isSaveTempPersonOk = false;
if (phoneNums != null && phoneNums.Length != 0)
{
foreach (var item in phoneNums)
{
//1.6 判断输入的联系人在是否存在在数据库中
if (!personBLL.AddValidation(item))
{
//1.7 不存在在数据库中，则将临时联系人添加进数据库
isSaveTempPersonOk = personBLL.DoAddTempPerson(PName_Temp, item, true, groupIds);
if (!isSaveTempPersonOk)
{
// return false;
}
}
//1.7 存在在数据库中，且已经在发送列表中，这种情况需讨论
}
}
return phoneNums.ToList();
}
/// <summary>
/// 判断传入的首元素的时间是否超过传入的时间间隔
/// </summary>
/// <param name="obj">首元素</param>
/// <param name="ts">允许的最大时间间隔</param>
/// <returns></returns>
public bool CheckFirstObjOvertime(PMS.Model.QueryModel.Redis_ListMsgIdObj obj, TimeSpan ts)
{
//
TimeSpan sp_now = new TimeSpan(DateTime.Now.Ticks);
TimeSpan sp_target = new TimeSpan(obj.Dt.Ticks);
//若对象内的时间已经超过指定的时间范围，则返回false
if (sp_now.Subtract(sp_target).Duration() > ts)
{
return true;
}
else
{
return false;
}
}
/// <summary>
/// 根据条件查询：角色名，备注
/// </summary>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <param name="rowCount"></param>
/// <param name="model"></param>
/// <param name="isAsc"></param>
/// <param name="isMiddle"></param>
/// <returns></returns>
public List<RoleInfo> GetRoleRecordListByQuery(int pageIndex, int pageSize, ref int rowCount, PMS.Model.ViewModel.ViewModel_RoleInfo_QueryInfo model, bool isAsc, bool isMiddle)
{
//1. 找到所有未被删除的用户对象列表，并转为中间件
var query = GetListBy(a => a.DelFlag == false).ToList().Select(u => u.ToMiddleModel()).ToList();
//2. 根据用户名查询
if (model.RoleName != null)
{
query = query.Where(c =>c.RoleName.Contains(model.RoleName)).ToList();
}
//3. 根据备注查询
if (model.Remark != null)
{
query = query.Where(c => c.Remark != null && c.Remark.Contains(model.Remark)).ToList();
}
//4. 获取查询结果条数
rowCount = query.Count();
return ToListByPage(query, pageIndex, pageSize, ref rowCount, isAsc, false);
}
/// <summary>
/// 编辑
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool EditJobTemplate(PMS.Model.ViewModel.ViewModel_JobTemplate model)
{
if(model != null)
{
var jobTemplate = this.GetListBy(p => p.JTID == model.JTID).FirstOrDefault();
jobTemplate.JobClassName = model.JobClassName;
jobTemplate.JobType = model.JobType;
jobTemplate.CronStr = model.CronStr;
jobTemplate.Remark = model.Remark;
jobTemplate.JobGroup = model.JobGroup;
try
{
this.Update(jobTemplate);
return true;
}
catch (Exception)
{
return false;
}
}
return false;
}
public void AddTrail(PMS.Model.DTO.Appraisal.Trail trail)
{
if (trail != null)
{
if (Lib.Utility.Common.IsNullOrEmptyList(lst_appraisal_trails))
{
lst_appraisal_trails = new List<Trail>();
}
lst_appraisal_trails.Add(trail);
}
}
public void AddReviewer(PMS.Model.DTO.Appraisal.Reviewer reviewer)
{
if (reviewer != null)
{
if (Lib.Utility.Common.IsNullOrEmptyList(lst_reviewers))
{
lst_reviewers = new List<PMS.Model.DTO.Appraisal.Reviewer>();
}
lst_reviewers.Add(reviewer);
}
}
public void AddKPI(PMS.Model.DTO.Appraisal.KPI kpi)
{
if (kpi != null)
{
if (Lib.Utility.Common.IsNullOrEmptyList(lst_kpi))
{
lst_kpi = new List<KPI>();
}
lst_kpi.Add(kpi);
}
}
public void AddCoreValue(PMS.Model.DTO.Appraisal.CoreValue coreValue)
{
if (coreValue != null)
{
if (Lib.Utility.Common.IsNullOrEmptyList(lst_core_values))
{
lst_core_values = new List<CoreValue>();
}
lst_core_values.Add(coreValue);
}
}
/// <summary>
/// 步骤三 获取短信内容
/// 封装要提交至联通接口的发送对象（含联系人电话号码）
/// </summary>
/// <param name="model">短信对象</param>
/// <param name="list_phones"></param>
/// <returns></returns>
public SMSModel_Send ToSendModel(PMS.Model.ViewModel.ViewModel_Message model,List<string> list_phones)
{
/*步骤三
获取短信内容
封装要提交至联通接口的发送对象
（含联系人电话号码）
*/
//2 获取短信内容
var content = model.Content;
//2.1 设置发送对象相关参数
string subCode = "";//短信子码"74431"，接收回馈信息用
string sign = "【国家海洋预报台】"; //短信签名，！仅在！发送短信时用= "【国家海洋预报台】";
//短信发送与查询所需参数
string smsContent = content;//短信内容
string sendTime;//计划发送时间，为空则立即发送
//3 对短信内容进行校验——先暂时不做
//6月27日新增将List电话集合转成用,拼接的字符串
//查询时不需要联系人电话
SMSModel_Send sendMsg = new SMSModel_Send()
{
account = "dh74381",
password = "******",
content = content,
phones = list_phones.ToArray(),
sendtime = DateTime.Now
};
return sendMsg;
}
/// <summary>
/// 延时发送
/// </summary>
/// <param name="msg"></param>
/// <returns></returns>
public bool SendMsgbyDelayed(PMS.Model.CombineModel.SendAndMessage_Model model,out SMSModel_Receive response)
{
//response = new PMS.Model.Message.BaseResponse();
//1 创建quartz父类客户端
// 不使用服务因为此处需要通过反射的方式创建作业实例
//Quartz_Service.JobServiceClient client = new Quartz_Service.JobServiceClient();
//ServiceReference_QuartzService.JobServiceClient client = new ServiceReference_QuartzService.JobServiceClient();
QuartzJobFactory.IJobService client = new QuartzJobFactory.JobService();
//2 创建发送作业实例（非模板）
/*此处需要实现：
1）向数据库写入创建的新的作业实例
2）创建该作业实例的关联表
*/
//var jobTemplateInstance= jobTemplateBLL.GetListBy(t => t.JTID == 3);
//jobInfoBLL.Create(new J_JobInfo() { JobName = "发送作业", JobClassName = "SendJob", NextRunTime=model.Model_Message.NextRunTime });
//找到对应的作业模板（发送作业模板）
//2.1 查找当前用户
var user_current= userInfoBLL.GetListBy(u =>u.ID== model.Model_Message.UID).FirstOrDefault();
//2.2 根据当前用户找到指定类型（jobType）的作业模板
var jobTemplate_target = (from t in user_current.J_JobTemplate
where t.JobType == Convert.ToInt32(PMS.Model.Enum.JobType_Enum.sendJob)
select t).FirstOrDefault();
//2.3 根据作业模板创建作业实例
// 调用J_JobInfoBLL中的AddJobInfo方法创建作业实例
J_JobInfo jobInstance = new J_JobInfo()
{
UID = model.Model_Message.UID,
CreateTime = DateTime.Now,
EndRunTime = model.Model_Message.EndRunTime == DateTime.MinValue ? model.Model_Message.StartRunTime : model.Model_Message.EndRunTime,//此处加入判断，若EndRunTime时间为1/1/1/1这种情况先将起始时间赋给他
NextRunTime = model.Model_Message.NextRunTime == DateTime.MinValue ? model.Model_Message.StartRunTime : model.Model_Message.NextRunTime,
StartRunTime = model.Model_Message.StartRunTime,
JobClassName = jobTemplate_target.JobClassName,
JobName = jobTemplate_target.JTName,
JobGroup = jobTemplate_target.JobGroup
};
//执行以下操作
//var jobInstance = jobInfoBLL.GetListBy(j => j.JID == 27).FirstOrDefault();
//3 创建JobData
var jobData = new PMS.Model.JobDataModel.SendJobDataModel()
{
//4 将前台传入的model值赋给JobData中的JobValue
JobDataValue=new PMS.Model.CombineModel.SendAndMessage_Model()
{
Model_Send=new SMSModel_Send()
{
account = model.Model_Send.account,
content = model.Model_Send.content,
msgid = model.Model_Send.msgid,
password = model.Model_Send.password,
phones = model.Model_Send.phones,
sendtime = model.Model_Send.sendtime,
subcode = model.Model_Send.subcode
},
Model_Message =new PMS.Model.ViewModel.ViewModel_Message()
{
UID = model.Model_Message.UID,
Content=model.Model_Send.content,
SMSMissionID=model.Model_Message.SMSMissionID
}
}
//JobDataValue = new PMS.Model.SMSModel.SMSModel_Send()
//{
// account = model.Model_Send.account,
// content = model.Model_Send.content,
// msgid = model.Model_Send.msgid,
// password = model.Model_Send.password,
// phones = model.Model_Send.phones,
// sendtime = model.Model_Send.sendtime,
// subcode = model.Model_Send.subcode
//}
};
//5 将发送作业实例添加至计划任务中
//注意此作业实例中需要含UID
jobInfoBLL.AddJobInfo(jobInstance, jobData);
//**** 11-16 创建jobInfo与其他的关联（以便在作业管理页面中显示）
//在job的bll层中创建作业（同时写入数据库，并添加至调度池中）
/*var response=*/
//12-6
//统一写在JobInfoBLL层中的AddJobInfo方法中
//QuartzProxy.QuartzServiceFacade quartzService = new QuartzProxy.QuartzServiceFacade(new QuartzProxy.QuartzServiceClientProxy());
//var response_base= quartzService.AddScheduleJob(jobInstance, jobData);
//client.AddScheduleJob(jobInstance, jobData);
response = new SMSModel_Receive() { result="0"};
return true;
}
public WrappedObserver(PMS parent) => _parent = parent;
public WrappedSubscribable(PMS parent) => _parent = parent;
/// <summary>
/// 立刻发送
/// </summary>
/// <param name="msg"></param>
/// <returns></returns>
public bool SendMsgbyNow(PMS.Model.CombineModel.SendAndMessage_Model model, out SMSModel_Receive receiveModel)
{
//SMSModel_Receive receiveModel = new SMSModel_Receive();
ServiceReference_SMSService.SMSServiceClient client = new ServiceReference_SMSService.SMSServiceClient();
//重新梳理并做抽象
#region 11-14 在控制器中已经调用这些方法（现写在控制器中），此处与控制器重复，注释掉
////1 根据选定的群组及部门获取相应的联系人
//var list_PersonPhonesByGroupAndDepartment = GetFinalPersonPhoneList(model.Model_Message, GetPersonListByGroupDepartment);
////2 获取临时联系人电话集合
//var list_tempPersonPhones = AddAndGetTempPersons(model.Model_Message, personBLL, groupBLL);
////2.2 获取最终的联系人电话集合
//list_PersonPhonesByGroupAndDepartment.AddRange(list_tempPersonPhones);
//var list_phones = list_PersonPhonesByGroupAndDepartment;
////3 转成发送对象
//var sendMsg = ToSendModel(model.Model_Message, list_phones);
/*步骤四
生成提交对象及短信及作业对象
由SMSFactory进行短信提交操作（并选择延时/立刻发送）
*/
//4 短信发送
//注意：desc:定时时间格式错误;
// result:定时时间格式错误
//PMS.Model.CombineModel.SendAndMessage_Model sendandMsgModel = new PMS.Model.CombineModel.SendAndMessage_Model() { Model_Message = model, Model_Send = sendMsg };
//model.Model_Send = sendMsg;
#endregion
// SMSModel_Receive receive = new SMSModel_Receive();
PMS.Model.Message.BaseResponse response = new PMS.Model.Message.BaseResponse();
client.SendMsg(model.Model_Send, out receiveModel);
//receiveModel = new SMSModel_Receive() { msgid = "210cb72fe038484fb2952d0db96e0ae7", desc = "提交成功", result = "0", failPhones = new string[] { "" } };
//发送之后执行将发送记录写会数据库的操作
this.AfterSend(model.Model_Message, receiveModel, model.Model_Send.phones.ToList(), this.redis_list_id, this.Interval_OverTime);
//SendMsg(model, out response);
return true;
}
public void AddAppraisalStage(PMS.Model.DTO.Appraisal.Stage appraisalStage)
{
if (appraisalStage != null)
{
if (Lib.Utility.Common.IsNullOrEmptyList(lst_appraisal_stages))
{
lst_appraisal_stages = new List<Stage>();
}
lst_appraisal_stages.Add(appraisalStage);
}
}
public void AddComment(PMS.Model.DTO.Appraisal.SectionComment comment)
{
if (comment != null)
{
if (Lib.Utility.Common.IsNullOrEmptyList(lst_comments))
{
lst_comments = new List<SectionComment>();
}
lst_comments.Add(comment);
}
}
public void AddApprover(PMS.Model.DTO.Appraisal.Approver approver)
{
if (approver != null)
{
if (Lib.Utility.Common.IsNullOrEmptyList(lst_approvers))
{
lst_approvers = new List<Approver>();
}
lst_approvers.Add(approver);
}
}
