/// <summary>
/// 任务执行的内容
/// </summary>
/// <param name="taskDetail">任务配置状态信息</param>
public void Execute(TaskDetail taskDetail)
{
if (searcher == null)
{
//检查是否分布式运行环境
bool distributedDeploy = Utility.IsDistributedDeploy();
if (distributedDeploy)
{
searcher = new FollowUserSearcher(SearchEngineService.GetSearchEngine("~/App_Data/IndexFiles/FollowUser"));
}
else
{
searcher = (FollowUserSearcher)SearcherFactory.GetSearcher(FollowUserSearcher.CODE);
}
}
//根据上次执行时间从数据库取关注实体列表
DateTime lastStart = new DateTime(1900, 1, 1);
if (taskDetail != null && taskDetail.LastStart.HasValue)
{
lastStart = taskDetail.LastStart.Value;
}
IEnumerable<long> userIds = followService.GetRecentFollowerUserIds(lastStart);
searcher.Update(userIds);
}
/// <summary>
/// 任务执行的内容
/// </summary>
/// <param name="taskDetail">任务配置状态信息</param>
public void Execute(TaskDetail taskDetail = null)
{
//检查是否分布式运行环境
bool distributedDeploy = Utility.IsDistributedDeploy();
if (distributedDeploy)
{
foreach (SearchEngine searchEngine in SearchEngineService.searchEngines.Values)
{
searchEngine.Commit();
}
}
else
{
IEnumerable<ISearcher> searchers = SearcherFactory.GetSearchersOfBaseLucene();
foreach (var searcher in searchers)
{
if (searcher.SearchEngine is SearchEngine)
{
((SearchEngine)searcher.SearchEngine).Commit();
}
}
}
}
/// <summary>
/// 任务执行的内容
/// </summary>
/// <param name="taskDetail">任务配置状态信息</param>
public void Execute(TaskDetail taskDetail)
{
IEnumerable<TenantAttachmentSettings> allTenantAttachmentSettings = TenantAttachmentSettings.GetAll();
foreach (var tenantAttachmentSettings in allTenantAttachmentSettings)
{
AttachmentService service = new AttachmentService(tenantAttachmentSettings.TenantTypeId);
service.DeleteTrashTemporaryAttachments();
}
}
/// <summary>
/// 任务执行的内容
/// </summary>
/// <param name="taskDetail">任务配置状态信息</param>
public void Execute(TaskDetail taskDetail)
{
new AttitudeRepository().DeleteTrashDatas();
new FavoriteRepository().DeleteTrashDatas(MultiTenantServiceKeys.Instance().Favorites());
new FavoriteRepository().DeleteTrashDatas(MultiTenantServiceKeys.Instance().Subscribe());
new AttachmentRepository<Attachment>().DeleteTrashDatas();
new AtUserRepository().DeleteTrashDatas();
new TagRepository<Tag>().DeleteTrashDatas();
//new CommentRepository().DeleteTrashDatas();
new CountRepository().DeleteTrashCount();
new RecommendItemRepository().DeleteTrashDatas();
}
/// <summary>
/// 任务执行的内容
/// </summary>
/// <param name="taskDetail">任务配置状态信息</param>
public void Execute(TaskDetail taskDetail)
{
SystemDataService systemDataService = new SystemDataService();
foreach (var perDayTenantTypeId in StageCountTypeManager.GetAllTenantTypeIds())
{
var stageCountTypeManager = StageCountTypeManager.Instance(perDayTenantTypeId);
ConcurrentDictionary<string, List<int>> allStageCountTypes = stageCountTypeManager.GetAllStageCountTypes();
foreach (var base2StageCountType in allStageCountTypes)
{
//批量更新计数表中的阶段计数
Dictionary<string, int> countType2Days = base2StageCountType.Value.ToDictionary(n => stageCountTypeManager.GetStageCountType(base2StageCountType.Key, n), n => n);
new CountRepository().UpdateStageCountPerDay(perDayTenantTypeId, base2StageCountType.Key, countType2Days);
//删除每日计数表中的过期的历史计数记录
int maxValue = stageCountTypeManager.GetMaxDayCount(base2StageCountType.Key);
new CountRepository().DeleteTrashCountPerDays(perDayTenantTypeId, base2StageCountType.Key, maxValue);
}
}
}
public void Execute(TaskDetail taskDetail = null)
{
EmailService emailService = new EmailService();
System.Collections.Generic.List<int> list = new System.Collections.Generic.List<int>();
System.Collections.Generic.List<int> list2 = new System.Collections.Generic.List<int>();
EmailTask.RWLock.EnterWriteLock();
IEmailSettingsManager emailSettingsManager = DIContainer.Resolve<IEmailSettingsManager>();
EmailSettings emailSettings = emailSettingsManager.Get();
System.Collections.Generic.Dictionary<int, MailMessage> dictionary = emailService.Dequeue(emailSettings.BatchSendLimit);
foreach (System.Collections.Generic.KeyValuePair<int, MailMessage> current in dictionary)
{
if (emailService.Send(current.Value))
{
list.Add(current.Key);
}
else
{
list2.Add(current.Key);
}
}
emailService.SendFailed(list2, emailSettings.SendTimeInterval, emailSettings.NumberOfTries);
emailService.Delete(list);
EmailTask.RWLock.ExitWriteLock();
}
/// <summary>
/// 任务执行的内容
/// </summary>
/// <param name="taskDetail">任务配置状态信息</param>
public void Execute(TaskDetail taskDetail)
{
new GroupRepository().CalculateGrowthValues();
}
/// <summary>
/// 任务执行的内容
/// </summary>
/// <param name="taskDetail">任务配置状态信息</param>
public void Execute(TaskDetail taskDetail)
{
RecommendService recommendService = new RecommendService();
recommendService.DeleteExpiredRecommendItems();
}
/// <summary>
/// 任务执行的内容
/// </summary>
/// <param name="taskDetail">任务配置状态信息</param>
public void Execute(TaskDetail taskDetail)
{
ContentItemService contentItemService = new ContentItemService();
contentItemService.ExpireStickyContentItems();
}
/// <summary>
/// 应用程序关闭时保存任务当前状态
/// </summary>
/// <param name="entity">任务详细信息实体</param>
public void SaveTaskStatus(TaskDetail entity)
{
taskDetailRepository.SaveTaskStatus(entity);
}
/// <summary>
/// 任务执行的内容
/// </summary>
/// <param name="taskDetail">任务配置状态信息</param>
public void Execute(TaskDetail taskDetail)
{
InviteFriendService inviteFriendService = new InviteFriendService();
inviteFriendService.DeleteTrashInvitationCodes();
}
/// <summary>
/// 实例化实体
/// </summary>
/// <remarks>实例化实体时先根据taskName从数据库中获取，如果取不到则创建新实例</remarks>
public static TaskDetail New()
{
TaskDetail taskDetail = new TaskDetail();
return(taskDetail);
}
/// <summary>
/// 任务执行的内容
/// </summary>
/// <param name="taskDetail">任务配置状态信息</param>
public void Execute(TaskDetail taskDetail)
{
new OnlineUserService().Refresh();
}
public void Update(TaskDetail entity)
{
this.taskDetailRepository.Update(entity);
TaskSchedulerFactory.GetScheduler().Update(entity);
}
public void SaveTaskStatus(TaskDetail entity)
{
this.taskDetailRepository.SaveTaskStatus(entity);
}
/// <summary>
/// 任务执行的内容
/// </summary>
/// <param name="taskDetail">任务配置状态信息</param>
public void Execute(TaskDetail taskDetail)
{
BarThreadService barThreadService = new BarThreadService();
barThreadService.ExpireStickyThreads();
}
/// <summary>
/// 任务执行的内容
/// </summary>
/// <param name="taskDetail">任务配置状态信息</param>
public void Execute(TaskDetail taskDetail)
{
new VisitRepository().ExecQueue();
}
/// <summary>
/// 任务执行的内容
/// </summary>
/// <param name="taskDetail">任务配置状态信息</param>
public void Execute(TaskDetail taskDetail)
{
IEnumerable<IReminderInfoAccessor> reminderInfoTypeAccessors = DIContainer.Resolve<IEnumerable<IReminderInfoAccessor>>();
//提醒信息类型查询实例集合
IEnumerable<IReminderSender> reminderSenders = DIContainer.Resolve<IEnumerable<IReminderSender>>();
//发送提醒实例集合
ReminderService reminderService = new ReminderService();//提醒业务逻辑实例
ReminderSettings reminderSettings = reminderSettingsManager.Get();//站点提醒设置
ConcurrentDictionary<int, ConcurrentDictionary<long, List<UserReminderInfo>>> waitSendDict = new ConcurrentDictionary<int, ConcurrentDictionary<long, List<UserReminderInfo>>>();
//遍历各种提醒信息类型
RWLock.EnterWriteLock();
foreach (var reminderInfoTypeAccessor in reminderInfoTypeAccessors)
{
int reminderInfoTypeId = reminderInfoTypeAccessor.ReminderInfoTypeId;
ReminderInfoType reminderInfoType = ReminderInfoType.Get(reminderInfoTypeAccessor.ReminderInfoTypeId);
if (reminderInfoType == null)
continue;
//查询该信息类型下的提醒信息集合
IEnumerable<UserReminderInfo> userReminderInfos = reminderInfoTypeAccessor.GetUserReminderInfos();
foreach (var userReminderInfo in userReminderInfos.ToList())
{
if (userReminderInfo.UserId <= 0)
continue;
foreach (var reminderMode in ReminderMode.GetAll())
{
int reminderModeId = reminderMode.ModeId;
UserReminderSettings userReminderSettings = reminderService.GetUserReminderSettings(userReminderInfo.UserId, reminderModeId, reminderInfoTypeId);
if (userReminderSettings == null)
continue;
//1. 判断用户是否启用了提醒并可以使用该提醒方式；
if (!userReminderSettings.IsEnabled)
continue;
if (!waitSendDict.ContainsKey(reminderModeId))
waitSendDict[reminderModeId] = new ConcurrentDictionary<long, List<UserReminderInfo>>();
if (!waitSendDict[reminderModeId].ContainsKey(userReminderInfo.UserId))
waitSendDict[reminderModeId][userReminderInfo.UserId] = new List<UserReminderInfo>();
//2. 从用户设置中取发送提醒时间阈值，遍历提醒信息集合筛选出超过此值的提醒信息集合；
IEnumerable<ReminderInfo> reminderInfos = userReminderInfo.ReminderInfos.ToList();
reminderInfos = reminderInfos.Where(n => n.DateCreated.AddMinutes(userReminderSettings.ReminderThreshold) <= DateTime.UtcNow).ToList();
//3. 再判断是否重复提醒用户
if (userReminderSettings.IsRepeated)
{
// 根据相应提醒记录的最后提醒时间和当前时间求差值是否大于重复提醒时间间隔进行筛选，如果提醒记录不存在也应筛选出
IEnumerable<ReminderRecord> records = reminderService.GetRecords(userReminderInfo.UserId, reminderModeId, reminderInfoTypeId);
reminderInfos = reminderInfos.Where(n =>
{
ReminderRecord record = records.FirstOrDefault(m => m.ObjectId == n.ObjectId);
if (record == null)
return true;
TimeSpan ts = DateTime.UtcNow - record.LastReminderTime;
return ts.TotalMinutes > userReminderSettings.RepeatInterval;
}).ToList();
if (reminderInfos.Count() == 0)
continue;
IEnumerable<long> objectIds = reminderInfos.Select(n => n.ObjectId);
//更新最后提醒时间
reminderService.UpdateRecoreds(userReminderInfo.UserId, reminderModeId, reminderInfoTypeId, objectIds);
}
else
{
// 根据是否提醒过筛选发送提醒信息集合
reminderInfos = reminderInfos.Where(n => !reminderService.IsExits(userReminderInfo.UserId, reminderModeId, reminderInfoTypeId, n.ObjectId)).ToList();
if (reminderInfos.Count() == 0)
continue;
//创建提醒记录
reminderService.CreateRecords(userReminderInfo.UserId, reminderModeId, reminderInfoTypeId, reminderInfos.Select(n => n.ObjectId));
}
userReminderInfo.SetReminderInfos(reminderInfos.ToList());
//生成处理地址
userReminderInfo.ProcessUrl = reminderInfoTypeAccessor.GetProcessUrl(userReminderInfo.UserId);
waitSendDict[reminderModeId][userReminderInfo.UserId].Add(userReminderInfo);
}
}
}
RWLock.ExitWriteLock();
if (waitSendDict != null && waitSendDict.Count > 0)
{
foreach (var reminderSender in reminderSenders)
{
if (!waitSendDict.ContainsKey(reminderSender.ReminderModeId))
{
continue;
}
foreach (KeyValuePair<long, List<UserReminderInfo>> pair in waitSendDict[reminderSender.ReminderModeId])
{
//发送提醒
reminderSender.SendReminder(pair.Value);
}
}
}
}
/// <summary>
/// 更新任务相关信息
/// </summary>
/// <param name="entity">任务详细信息实体</param>
public void Update(TaskDetail entity)
{
taskDetailRepository.Update(entity);
TaskSchedulerFactory.GetScheduler().Update(entity);
}
