public async Task AddCalendar(string schedulerName, string calendarName, bool replace, bool updateTriggers)
{
var scheduler = await SchedulerHelper.GetScheduler(schedulerName).ConfigureAwait(false);
ICalendar calendar = null;
await scheduler.AddCalendar(calendarName, calendar, replace, updateTriggers).ConfigureAwait(false);
}
public HttpResponseMessage SaveKeys()
{
try
{
var keys = Request.GetHttpContext().Request["Keys"];
var model = new CacheKeysModel();
model.Keys = JsonConvert.DeserializeObject <List <CacheKeyModel> >(keys);
var taskEnabled = bool.Parse(Request.GetHttpContext().Request["TaskEnabled"]);
PortalController.Instance.UpdatePortalSetting(PortalSettings.PortalId, Constants.PsCacheKeysToClear(PortalSettings.PortalId), keys, true, null, false);
if (SchedulerHelper.IsScheduleItemEnabled(TaskTypeName, TaskAssembly) != taskEnabled)
{
if (taskEnabled)
{
SchedulerHelper.EnableScheduleItem(TaskTypeName, TaskAssembly);
}
else
{
SchedulerHelper.DisableScheduleItem(TaskTypeName, TaskAssembly);
}
}
return(Request.CreateResponse(System.Net.HttpStatusCode.NoContent));
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid Json"));
}
}
protected override void OnStart(string[] args)
{
Task.Run(() =>
{
SchedulerHelper.Start();
});
}
public override IPublisher <int> CreatePublisher(long elements)
{
var dp = new MulticastPublisher <int>();
Task.Factory.StartNew(() => {
while (!dp.HasSubscribers)
{
Thread.Sleep(10);
}
long start = SchedulerHelper.NowUTC();
for (int i = 0; i < elements; i++)
{
while (!dp.Offer(i))
{
Thread.Sleep(1);
if (SchedulerHelper.NowUTC() - start > 1000)
{
return;
}
}
}
dp.Dispose();
}, TaskCreationOptions.LongRunning);
return(dp);
}
public async void ResumeJob_ExistingJob()
{
var quartz = await SchedulerHelper.CreateScheduler();
var service = SetupService(quartz);
await service.CreateOrUpdate(1, CRON_EVERY_FIVE_MINUTES);
DateTime?nextRun = await service.GetNextRunTime(1);
Assert.NotNull(nextRun);
Assert.True(nextRun > DateTime.Now);
await service.PauseJob(1);
DateTime?nextRunPaused = await service.GetNextRunTime(1);
Assert.Null(nextRunPaused);
await service.ResumeJob(1);
DateTime?nextRunResumed = await service.GetNextRunTime(1);
Assert.NotNull(nextRunResumed);
Assert.True(nextRunResumed > DateTime.Now);
}
public async Task AddJob(string schedulerName, string jobGroup, string jobName, string jobType, bool durable, bool requestsRecovery, bool replace = false)
{
var scheduler = await SchedulerHelper.GetScheduler(schedulerName).ConfigureAwait(false);
var jobDetail = new JobDetailImpl(jobName, jobGroup, Type.GetType(jobType), durable, requestsRecovery);
await scheduler.AddJob(jobDetail, replace).ConfigureAwait(false);
}
public async Task ResumeJobs(string schedulerName, GroupMatcherModel groupMatcher)
{
var scheduler = await SchedulerHelper.GetScheduler(schedulerName).ConfigureAwait(false);
var matcher = (groupMatcher ?? new GroupMatcherModel()).GetJobGroupMatcher();
await scheduler.ResumeJobs(matcher).ConfigureAwait(false);
}
public async Task <bool> Update(UpdatePushNotificationModel model)
{
var pushNotification = await _repository.Filter <PushNotification>(x =>
x.Id == model.Id && x.PushNotificationStatusType == PushNotificationStatusType.Scheduled).FirstOrDefaultAsync();
pushNotification.Description = model.Description;
pushNotification.Title = model.Title;
pushNotification.PushNotificationUserType = model.PushNotificationUserType;
pushNotification.PushNotificationActionType = model.PushNotificationActionType;
pushNotification.PushNotificationStatusType = model.SendingDate > DateTime.UtcNow
? PushNotificationStatusType.Scheduled
: PushNotificationStatusType.Sent;
pushNotification.SendingDate = model.SendingDate;
_repository.Update(pushNotification);
await _repository.SaveChangesAsync();
if (pushNotification.PushNotificationStatusType == PushNotificationStatusType.Scheduled)
{
var date = new DateTime(pushNotification.SendingDate.Year, pushNotification.SendingDate.Month,
pushNotification.SendingDate.Day, pushNotification.SendingDate.Hour,
pushNotification.SendingDate.Minute, pushNotification.SendingDate.Second);
var sendPushTriggerBuilder = TriggerBuilder.Create()
.WithIdentity($"{nameof(PushNotificationSendingJob)}Trigger#{PushNotificationSendingJob.Name}{pushNotification.Id}")
.StartAt(date);
dynamic sendPushProp = new ExpandoObject();
sendPushProp.pushNotificationId = pushNotification.Id;
await SchedulerHelper.ReSchedule <PushNotificationSendingJob, IJobListener>(new QuartzScheduleModel
{
Name = $"{PushNotificationSendingJob.Name}{pushNotification.Id}",
IsListenerRequested = false,
DataMap = sendPushProp,
TriggerBuilder = sendPushTriggerBuilder
});
}
else
{
switch (pushNotification.PushNotificationUserType)
{
case PushNotificationUserType.All:
await SendNotificationUsers(pushNotification, model.AnousmentId);
await SendNotificationGuests(pushNotification, model.AnousmentId);
break;
case PushNotificationUserType.Guest:
await SendNotificationGuests(pushNotification, model.AnousmentId);
break;
case PushNotificationUserType.Registered:
await SendNotificationUsers(pushNotification, model.AnousmentId);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(true);
}
private List <ScheduleRule> UpdateRules(List <ScheduleRule> rules, TimerInfo timerInfo, SeriesTimerInfo seriesTimerInfo)
{
if (timerInfo != null)
{
//Single Recording
SchedulerHelper.AppendTitleRule(rules, 0, timerInfo.Name);
SchedulerHelper.AppendChannelsRule(rules, false, new List <Guid> {
Guid.Parse(timerInfo.ChannelId)
});
SchedulerHelper.AppendOnDateAndDaysOfWeekRule(rules, ScheduleDaysOfWeek.None, timerInfo.StartDate.ToLocalTime());
SchedulerHelper.AppendAroundTimeRule(rules, timerInfo.StartDate.ToLocalTime());
}
else if (seriesTimerInfo != null)
{
//Serie Recording
SchedulerHelper.AppendTitleRule(rules, 0, seriesTimerInfo.Name);
SchedulerHelper.AppendOnDateAndDaysOfWeekRule(rules, SchedulerHelper.GetScheduleDaysOfWeek(seriesTimerInfo.Days), seriesTimerInfo.StartDate.ToLocalTime());
SchedulerHelper.AppendNewEpisodesOnlyRule(rules, seriesTimerInfo.RecordNewOnly);
if (!seriesTimerInfo.RecordAnyTime)
{
SchedulerHelper.AppendAroundTimeRule(rules, seriesTimerInfo.StartDate.ToLocalTime());
}
if (!seriesTimerInfo.RecordAnyChannel)
{
SchedulerHelper.AppendChannelsRule(rules, false, new List <Guid> {
Guid.Parse(seriesTimerInfo.ChannelId)
});
}
}
return(rules);
}
public async Task PauseTriggers(string schedulerName, GroupMatcherModel groupMatcher)
{
var scheduler = await SchedulerHelper.GetScheduler(schedulerName).ConfigureAwait(false);
var matcher = (groupMatcher ?? new GroupMatcherModel()).GetTriggerGroupMatcher();
await scheduler.PauseTriggers(matcher).ConfigureAwait(false);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterRoutes(RouteTable.Routes);
SchedulerHelper.InitializeFactory();
}
public async void ResumeJob_NotExistingJob()
{
var quartz = await SchedulerHelper.CreateScheduler();
var service = SetupService(quartz);
await service.ResumeJob(1);
}
public async Task <SchedulerModel> SchedulerDetails(string schedulerName)
{
var scheduler = await SchedulerHelper.GetScheduler(schedulerName).ConfigureAwait(false);
var metaData = await scheduler.GetMetaData().ConfigureAwait(false);
return(new SchedulerModel(scheduler, metaData));
}
public async Task <JobDetailModel> JobDetails(string schedulerName, string jobGroup, string jobName)
{
var scheduler = await SchedulerHelper.GetScheduler(schedulerName).ConfigureAwait(false);
var jobDetail = await scheduler.GetJobDetail(new JobKey(jobName, jobGroup)).ConfigureAwait(false);
return(new JobDetailModel(jobDetail));
}
public async Task <CalendarDetailModel> CalendarDetails(string schedulerName, string calendarName)
{
var scheduler = await SchedulerHelper.GetScheduler(schedulerName).ConfigureAwait(false);
var calendar = await scheduler.GetCalendar(calendarName).ConfigureAwait(false);
return(CalendarDetailModel.Create(calendar));
}
public async Task <IReadOnlyList <CurrentlyExecutingJobModel> > CurrentlyExecutingJobs(string schedulerName)
{
var scheduler = await SchedulerHelper.GetScheduler(schedulerName).ConfigureAwait(false);
var currentlyExecutingJobs = await scheduler.GetCurrentlyExecutingJobs().ConfigureAwait(false);
return(currentlyExecutingJobs.Select(x => new CurrentlyExecutingJobModel(x)).ToList());
}
public async Task <IReadOnlyList <string> > Calendars(string schedulerName)
{
var scheduler = await SchedulerHelper.GetScheduler(schedulerName).ConfigureAwait(false);
var calendarNames = await scheduler.GetCalendarNames().ConfigureAwait(false);
return(calendarNames);
}
public void Start()
{
if (ConstValues.Scheduler != null)
{
return;
}
var schedulerFactory = new StdSchedulerFactory(ConstValues.QuartzConfigs);
ConstValues.Scheduler = schedulerFactory.GetScheduler().Result;
ConstValues.Scheduler.Start().Wait();
var jobs = ConstValues.Scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup()).Result;
if (jobs.Any())
{
ConstValues.Scheduler.ResumeJobs(GroupMatcher <JobKey> .AnyGroup());
}
if (!ConstValues.IsServerConnected)
{
return;
}
var statisticsJob = new JobKey($"{nameof(StatisticsDataRemoveJob)}#{StatisticsDataRemoveJob.Name}");
var statisticsJobDetails = ConstValues.Scheduler.GetJobDetail(statisticsJob).Result;
if (statisticsJobDetails == null)
{
//--Not Cron DateTime
//var trigger = TriggerBuilder.Create()
// .WithIdentity($"{nameof(StatisticsDataRemoveJob)}#{StatisticsDataRemoveJob.Name}Trigger")
// .StartNow()
// .WithSimpleSchedule(x => x.WithInterval(TimeSpan.FromDays(1)).RepeatForever());
var trigger = TriggerBuilder.Create()
.WithIdentity($"{nameof(StatisticsDataRemoveJob)}Trigger#{StatisticsDataRemoveJob.Name}")
.WithCronSchedule("0 0 0 ? * * *");
SchedulerHelper.Schedule <StatisticsDataRemoveJob, IJobListener>(new QuartzScheduleModel
{
Name = StatisticsDataRemoveJob.Name,
TriggerBuilder = trigger,
IsListenerRequested = false,
DataMap = null
}).ConfigureAwait(true);
}
var currencyJob = new JobKey($"{nameof(AnnoucmentPricesJob)}#{AnnoucmentPricesJob.Name}");
var currencyJobDetails = ConstValues.Scheduler.GetJobDetail(currencyJob).Result;
if (currencyJobDetails == null)
{
var trigger = TriggerBuilder.Create()
.WithIdentity($"{nameof(AnnoucmentPricesJob)}Trigger#{AnnoucmentPricesJob.Name}")
.WithCronSchedule("0 0 10 ? * * *");
SchedulerHelper.Schedule <AnnoucmentPricesJob, IJobListener>(new QuartzScheduleModel
{
Name = AnnoucmentPricesJob.Name,
TriggerBuilder = trigger,
IsListenerRequested = false,
DataMap = null
}).ConfigureAwait(true);
}
}
public async Task <IReadOnlyList <KeyModel> > Jobs(string schedulerName, GroupMatcherModel groupMatcher)
{
var scheduler = await SchedulerHelper.GetScheduler(schedulerName).ConfigureAwait(false);
var matcher = (groupMatcher ?? new GroupMatcherModel()).GetJobGroupMatcher();
var jobKeys = await scheduler.GetJobKeys(matcher).ConfigureAwait(false);
return(jobKeys.Select(x => new KeyModel(x)).ToList());
}
public async void GetNextRunTime_NotExistingJob()
{
var quartz = await SchedulerHelper.CreateScheduler();
var service = SetupService(quartz);
DateTime?nextRun = await service.GetNextRunTime(2);
Assert.Null(nextRun);
}
public async void AddJob()
{
var quartz = await SchedulerHelper.CreateScheduler();
var service = SetupService(quartz);
await service.CreateOrUpdate(1, CRON_EVERY_FIVE_MINUTES);
bool jobAdded = await quartz.CheckExists(new JobKey(1.ToString()));
Assert.True(jobAdded);
}
public async Task <TriggerDetailModel> TriggerDetails(string schedulerName, string triggerGroup, string triggerName)
{
var scheduler = await SchedulerHelper.GetScheduler(schedulerName).ConfigureAwait(false);
var trigger = await scheduler.GetTrigger(new TriggerKey(triggerName, triggerGroup)).ConfigureAwait(false);
var calendar = trigger.CalendarName != null
? await scheduler.GetCalendar(trigger.CalendarName).ConfigureAwait(false)
: null;
return(TriggerDetailModel.Create(trigger, calendar));
}
protected override void OnStop()
{
SchedulerHelper op = new SchedulerHelper();
op.shutdown();
ScheduleBase.Scheduler.Shutdown(true);
//using (FileStream stream = new FileStream(filePath, FileMode.Append))
//using (StreamWriter writer = new StreamWriter(stream))
//{
// writer.WriteLine($"{DateTime.Now},服务停止！");
//}
}
public async void GetCronStringForJob()
{
var quartz = await SchedulerHelper.CreateScheduler();
var service = SetupService(quartz);
await service.CreateOrUpdate(1, CRON_EVERY_FIVE_MINUTES);
string cronSchedule = await service.GetCronSchedule(1);
Assert.Equal(CRON_EVERY_FIVE_MINUTES, cronSchedule);
}
/// <summary>
/// Get the recurrent recordings
/// </summary>
/// <param name="cancellationToken">The CancellationToken</param>
/// <returns></returns>
public async Task <IEnumerable <SeriesTimerInfo> > GetSeriesTimersAsync(CancellationToken cancellationToken)
{
_logger.Info(string.Format("[ArgusTV] Start GetSeriesTimer Async"));
await EnsureConnectionAsync(cancellationToken);
List <SeriesTimerInfo> seriesTimerInfos = new List <SeriesTimerInfo>();
try
{
List <UpcomingRecording> upcomingRecordings = Proxies.ControlService.GetAllUpcomingRecordings(UpcomingRecordingsFilter.Recordings).Result.GroupBy(u => u.Program.ScheduleId).Select(grp => grp.First()).ToList();
foreach (UpcomingRecording upcomingRecording in upcomingRecordings)
{
if (upcomingRecording != null && upcomingRecording.Program != null && upcomingRecording.Program.IsPartOfSeries)
{
var schedule = Proxies.SchedulerService.GetScheduleById(upcomingRecording.Program.ScheduleId).Result;
ScheduleRule daysOfWeekRule = schedule.Rules.SingleOrDefault(r => r.Type == ScheduleRuleType.DaysOfWeek);
var days = new List <DayOfWeek>();
if (daysOfWeekRule != null)
{
days = SchedulerHelper.GetDaysOfWeek((ScheduleDaysOfWeek)daysOfWeekRule.Arguments[0]);
}
seriesTimerInfos.Add(new SeriesTimerInfo
{
Id = upcomingRecording.Program.ScheduleId.ToString(),
ChannelId = upcomingRecording.Program.Channel.ChannelId.ToString(),
Name = upcomingRecording.Title,
Overview = Proxies.GuideService.GetProgramById(Guid.Parse(upcomingRecording.Program.GuideProgramId.ToString())).Result.Description,
StartDate = upcomingRecording.ActualStartTimeUtc,
ProgramId = upcomingRecording.Program.GuideProgramId.ToString(),
EndDate = upcomingRecording.ActualStopTimeUtc,
PostPaddingSeconds = upcomingRecording.Program.PostRecordSeconds,
PrePaddingSeconds = upcomingRecording.Program.PreRecordSeconds,
Days = days
});
}
}
UtilsHelper.DebugInformation(_logger, string.Format("[ArgusTV] GetSeriesTimers with the following TimerInfo: {0}", _jsonSerializer.SerializeToString(seriesTimerInfos)));
}
catch (Exception ex)
{
_logger.ErrorException("[ArgusTV] GetSeriesTimers async failed", ex);
throw new LiveTvConflictException();
}
return(seriesTimerInfos);
}
public async Task Start(string schedulerName, int?delayMilliseconds = null)
{
var scheduler = await SchedulerHelper.GetScheduler(schedulerName).ConfigureAwait(false);
if (delayMilliseconds == null)
{
await scheduler.Start().ConfigureAwait(false);
}
else
{
await scheduler.StartDelayed(TimeSpan.FromMilliseconds(delayMilliseconds.Value)).ConfigureAwait(false);
}
}
public IActionResult Get(string id)
{
// 不支持匿名函数
// Expression<Func<Task>> methoCall1 = () => Task.Factory.StartNew((s) => Console.WriteLine("task1" + s), "aaaa");
Expression <Func <Task> > methoCall3 = () => _job1.DoTask("22222222222");
SchedulerHelper.AddOrUpdateJob("jobId3", methoCall3, "17 12 * * *", "ivr_yzx");
return(Ok(id));
}
protected override void OnStop()
{
try
{
SchedulerHelper op = new SchedulerHelper();
op.shutdown();
LogWriter.info("服务结束" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
}
catch (Exception ex)
{
LogWriter.error("服务结束异常：" + ex.ToString());
}
}
public void SetHost(HomeGenieService hg, SchedulerItem item)
{
homegenie = hg;
schedulerItem = item;
Reset();
netHelper = new NetHelper(homegenie);
serialPortHelper = new SerialPortHelper();
tcpClientHelper = new TcpClientHelper();
udpClientHelper = new UdpClientHelper();
mqttClientHelper = new MqttClientHelper();
knxClientHelper = new KnxClientHelper();
schedulerHelper = new SchedulerHelper(homegenie);
programHelper = new ProgramHelperBase(homegenie);
}
/// <summary>
/// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
/// </summary>
/// <param name="app">The passed in Application Builder.</param>
/// <param name="env">The passed in Environment.</param>
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
this.logger.LogInformation($"Hosting Environment: {env!.EnvironmentName}");
this.startupConfig.UseForwardHeaders(app);
this.startupConfig.UseHttp(app);
this.startupConfig.UseContentSecurityPolicy(app);
app.UseStaticFiles();
this.startupConfig.UseAuth(app);
if (!env.IsDevelopment())
{
app.UseResponseCompression();
}
app.UseEndpoints(endpoints =>
{
endpoints.MapDefaultControllerRoute();
endpoints.MapRazorPages();
endpoints.MapControllers();
endpoints.MapHangfireDashboard(string.Empty, new DashboardOptions
{
DashboardTitle = this.configuration.GetValue <string>("DashboardTitle", "Hangfire Dashboard"),
AppPath = $"{this.configuration.GetValue<string>("JobScheduler:AdminHome")}",
Authorization = new List <IDashboardAuthorizationFilter> {
}, // Very important to set this, or Authorization won't work.
})
.RequireAuthorization("AdminUserPolicy");
});
app.UseHangfireServer();
// Schedule Health Gateway Jobs
BackgroundJob.Enqueue <DBMigrationsJob>(j => j.Migrate());
SchedulerHelper.ScheduleJob <ICommunicationJob>(this.configuration, "CreateCommEmailsForNewCommunications", j => j.CreateCommunicationEmailsForNewCommunications());
SchedulerHelper.ScheduleJob <IEmailJob>(this.configuration, "SendLowPriorityEmail", j => j.SendLowPriorityEmails());
SchedulerHelper.ScheduleJob <IEmailJob>(this.configuration, "SendStandardPriorityEmail", j => j.SendStandardPriorityEmails());
SchedulerHelper.ScheduleJob <IEmailJob>(this.configuration, "SendHighPriorityEmail", j => j.SendHighPriorityEmails());
SchedulerHelper.ScheduleJob <IEmailJob>(this.configuration, "SendUrgentPriorityEmail", j => j.SendUrgentPriorityEmails());
SchedulerHelper.ScheduleDrugLoadJob <FedDrugJob>(this.configuration, "FedApprovedDatabase");
SchedulerHelper.ScheduleDrugLoadJob <FedDrugJob>(this.configuration, "FedMarketedDatabase");
SchedulerHelper.ScheduleDrugLoadJob <FedDrugJob>(this.configuration, "FedCancelledDatabase");
SchedulerHelper.ScheduleDrugLoadJob <FedDrugJob>(this.configuration, "FedDormantDatabase");
SchedulerHelper.ScheduleDrugLoadJob <ProvincialDrugJob>(this.configuration, "PharmaCareDrugFile");
SchedulerHelper.ScheduleJob <NotifyUpdatedLegalAgreementsJob>(this.configuration, "NotifyUpdatedLegalAgreements", j => j.Process());
SchedulerHelper.ScheduleJob <CloseAccountJob>(this.configuration, "CloseAccounts", j => j.Process());
SchedulerHelper.ScheduleJob <OneTimeJob>(this.configuration, "OneTime", j => j.Process());
SchedulerHelper.ScheduleJob <CleanCacheJob>(this.configuration, "CleanCache", j => j.Process());
// SchedulerHelper.ScheduleJob<DeleteEmailJob>(this.configuration, "DeleteEmailJob", j => j.DeleteOldEmails());
}
