private ITrigger GetTrigger(IJobDetail jobDetail)
{
TriggerBuilder builder = TriggerBuilder
.Create()
.ForJob(jobDetail)
.WithDescription(txtTriggerDescription.Text.Trim())
.WithIdentity(new TriggerKey(txtTriggerName.Text.Trim(), txtTriggerGroup.Text.Trim()));
if (cboTriggerType.SelectedText == "Simple")
{
return(builder.WithSchedule(SimpleScheduleBuilder.Create()).Build());
}
return(builder.WithSchedule(CronScheduleBuilder.CronSchedule(txtCronExpression.Text)).Build());
}
public static TriggerBuilder WithWeeklyTrigger(this TriggerBuilder builder, Action <WeeklyTriggerBuilder> action)
{
var wb = new WeeklyTriggerBuilder();
action(wb);
return(builder.WithSchedule(wb));
}
public static TriggerBuilder WithCronPauseAwareCronSchedule(this TriggerBuilder triggerBuilder, string cronExpression, Action <PauseAwareCronScheduleBuilder> action)
{
PauseAwareCronScheduleBuilder cronScheduleBuilder = PauseAwareCronScheduleBuilder.CronSchedule(cronExpression);
action(cronScheduleBuilder);
return(triggerBuilder.WithSchedule(cronScheduleBuilder));
}
private TriggerBuilder AddMonthly(TriggerBuilder triggerBuilder, ScheduleModel scheduler)
{
var startTime = scheduler.StarTime;
return(triggerBuilder.WithSchedule(
CronScheduleBuilder.MonthlyOnDayAndHourAndMinute(startTime.Day, startTime.Hour, startTime.Minute)));
}
public static TriggerBuilder WithItinerarySchedule(this TriggerBuilder triggerBuilder, ISchedule schedule, DateTime rangeStart, Action <ItineraryScheduleBuilder> action)
{
var builder = ItineraryScheduleBuilder.ItinerarySchedule(schedule, rangeStart);
action(builder);
return(triggerBuilder.WithSchedule(builder));
}
public static async Task StartAsync(CronScheduleBuilder cronStart, JobDataMap data, bool startNow = false)
{
TriggerBuilder builder = TriggerBuilder.Create();
builder.WithSchedule(cronStart);
if (startNow)
{
builder.StartNow();
}
var schedulerFactory = new StdSchedulerFactory();
var scheduler = await schedulerFactory.GetScheduler();
await scheduler.Start();
await scheduler.ScheduleJob(JobBuilder.Create <ChangedTokenJob>().UsingJobData(data).Build(), builder.Build());
}
public static string create_job(JOB_TYPE type, string group_name, Dictionary <string, object> para = null, string schedule = null)
{
if (para == null)
{
para = new Dictionary <string, object>()
{
}
}
;
group_name = group_name.ToLower();
string name = group_name + "." + DateTime.Now.ToString("yyMMdd-HHmmss-fff");
if (!string.IsNullOrEmpty(schedule))
{
name += "." + schedule;
}
JobDataMap m = new JobDataMap();
m.Put("ID___", name);
m.Put("SCHEDULE___", schedule);
m.Put("TYPE___", type);
m.Put("CURRENT_ID___", 0);
m.Put("COUNTER___", new ConcurrentDictionary <long, bool>());
m.Put("PARA___", para);
JobBuilder job = null;
TriggerBuilder trigger = null;
switch (type)
{
case JOB_TYPE.CRAWLER_NET:
case JOB_TYPE.CRAWLER_CURL:
job = JobBuilder.Create <JobCrawler>();
break;
case JOB_TYPE.API_JS:
job = JobBuilder.Create <JobApiJS>();
break;
}
if (job != null)
{
job = job.WithIdentity(name, group_name).UsingJobData(m);
trigger = TriggerBuilder.Create();
if (!string.IsNullOrEmpty(schedule))
{
trigger = trigger.WithSchedule(CronScheduleBuilder.CronSchedule(schedule));
}
trigger = trigger.StartNow();
var j = job.Build();
var t = trigger.Build();
m_scheduler.ScheduleJob(j, t);
m_job.TryAdd(name, j);
m_trigger.TryAdd(name, t);
m_scheduler.ScheduleJob(j, t).Wait();
return(name);
}
return(string.Empty);
}
/// <summary>
/// Handles with a given text matches the Expression4 field.
/// </summary>
/// <param name="nameValueCollection">A collection of values from the named capture groups.</param>
/// <param name="results">The results.</param>
private void Expression4Handler(NameValueCollection nameValueCollection, TimeZoneInfo timeZone, TextToScheduleResults results)
{
// every [n] (days|weeks|months|years) (from [date]) (at [time])
string amountString = nameValueCollection["AMOUNT"];
string intervalString = nameValueCollection["INTERVALUNIT"];
var dateSpec = nameValueCollection["DATESPEC"];
var dayOfWeekSpecs = nameValueCollection.GetValues("DAYOFWEEK");
var timesToFire = nameValueCollection.GetValues("TIME");
DateTime?triggerStartTime = null;
if (dayOfWeekSpecs != null && GrammarHelper.GetIntervalUnitValueFromString(intervalString) != IntervalUnit.Week)
{
throw new Exception("You should only specify a day of the week, when you are using the \"week\" time interval.");
}
if (timesToFire == null) // if times are not specified assume midnight
{
timesToFire = new string[] { "00:00" }
}
;
foreach (var timeString in timesToFire)
{
if (dateSpec != null || timeString != null)
{
triggerStartTime = GrammarHelper.GetDateTimeFromDateSpecAndTime(dateSpec, timeString);
}
if (dayOfWeekSpecs != null)
{
var dayOfWeeks = GrammarHelper.GetDayOfWeekValues(dayOfWeekSpecs);
foreach (var dayOfWeek in dayOfWeeks)
{
if (triggerStartTime == null)
{
triggerStartTime = SystemTime.Now().DateTime;
}
DateTime dowTriggerStartTime = triggerStartTime.Value;
//seek
dowTriggerStartTime = SeekForwardToNextDayOfWeek(dowTriggerStartTime, dayOfWeek);
TriggerBuilder triggerBuilder = TriggerBuilder.Create();
triggerBuilder.WithSchedule(CreateScheduleWithAmountAndIntervalUnit(amountString, intervalString, timeZone));
triggerBuilder.StartAt(new DateTimeOffset(dowTriggerStartTime, timeZone.GetUtcOffset(dowTriggerStartTime)));
results.Add(triggerBuilder, null);
}
}
else
{
TriggerBuilder triggerBuilder = TriggerBuilder.Create();
triggerBuilder.WithSchedule(CreateScheduleWithAmountAndIntervalUnit(amountString, intervalString, timeZone));
//start on from time
if (triggerStartTime != null)
{
triggerBuilder.StartAt(new DateTimeOffset(triggerStartTime.Value, timeZone.GetUtcOffset(triggerStartTime.Value)));
}
results.Add(triggerBuilder, null);
}
}
}
/// <summary>
/// Handles with a given text matches the Expression1 field.
/// </summary>
/// <param name="nameValueCollection">A collection of values from the named capture groups.</param>
/// <param name="results">The results.</param>
private void Expression1Handler(NameValueCollection nameValueCollection, TimeZoneInfo timeZone, TextToScheduleResults results)
{
var amountString = nameValueCollection["AMOUNT"];
var intervalUnitString = nameValueCollection["INTERVALUNIT"];
var startDateString = nameValueCollection["DATESPEC"];
var time = nameValueCollection["TIME"];
var fromTime = nameValueCollection["FROMTIME"];
var toTime = nameValueCollection["TOTIME"];
var dayOfWeekSpecs = nameValueCollection.GetValues("DAYOFWEEK");
var monthSpecs = nameValueCollection.GetValues("MONTH");
DateTime?triggerStartTime = null;
ICalendar calendar = null;
//DAY OF WEEK SPECS
if (dayOfWeekSpecs != null)
{
calendar = BuildCalendarOnDayOfWeek(calendar, dayOfWeekSpecs, timeZone);
}
//MONTH SPECS
if (monthSpecs != null)
{
calendar = BuildCalendarOnMonths(calendar, monthSpecs, timeZone);
}
//TIME (single or range)
//check for ranged time
if (fromTime != null && toTime != null)
{
calendar = BuildCalendarOnTimeRange(calendar, fromTime, toTime, timeZone);
//set the start date as the from time
DateTime?fromTimeStartDate = GrammarHelper.GetTimeFromTimeString(fromTime);
triggerStartTime = fromTimeStartDate;
}
//is regular time, process as single time provided
else if (time != null)
{
DateTime?timeStartDate = GrammarHelper.GetTimeFromTimeString(time);
triggerStartTime = timeStartDate;
}
//BUILD TRIGGER
TriggerBuilder triggerBuilder = TriggerBuilder.Create();
//set schedule
triggerBuilder.WithSchedule(CreateScheduleWithAmountAndIntervalUnit(amountString, intervalUnitString, timeZone));
//start on from time
if (triggerStartTime != null)
{
triggerBuilder.StartAt(new DateTimeOffset(triggerStartTime.Value, timeZone.GetUtcOffset(triggerStartTime.Value)));
}
results.Add(triggerBuilder, calendar);
}
private TriggerBuilder AddDaily(TriggerBuilder triggerBuilder, ScheduleModel scheduler)
{
return(triggerBuilder.WithSchedule(
CronScheduleBuilder.DailyAtHourAndMinute(scheduler.StarTime.Hour, scheduler.StarTime.Minute)));
}
