/// <summary>
/// Adds a trigger that executes once at specified state change.
/// </summary>
/// <param name="changeType">Type of the change.</param>
/// <returns>
/// <see cref="TriggerBuilder" /> instance.
/// </returns>
public TriggerBuilder OnStateChange(TaskSessionStateChangeType changeType)
{
var b = new TriggerBuilder(tb, TaskTriggerType.SessionStateChange);
((SessionStateChangeTrigger)b.trigger).StateChange = changeType;
return b;
}
static void Main(string[] args)
{
RESTApi.ServerUrl = "http://*****:*****@gmail.com");
//msg.To.Add(tmp.user.Email);
msg.To.Add("*****@*****.**");
msg.Subject = "Status your work " + DateTime.Now.ToString();
msg.Body = tmp.user.FullName + ", " + tmp.problem.Subject + " " + tmp.state.Status;
SmtpClient client = new SmtpClient();
client.UseDefaultCredentials = true;
client.Host = "smtp.gmail.com";
client.Port = 587;
client.EnableSsl = true;
client.DeliveryMethod = SmtpDeliveryMethod.Network;
client.Credentials = new NetworkCredential("*****@*****.**", "Qwerty`123");
client.Timeout = 20000;
try
{
client.Send(msg);
Console.WriteLine("Mail has been successfully sent!");
}
catch (Exception ex)
{
Console.WriteLine("Fail Has error" + ex.Message);
}
finally
{
msg.Dispose();
}
tempStudentFiles[tmp.problem.TeacherId].Add(tmp);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
};
channel.BasicConsume("QStudentFiles", true, consumer);
Console.WriteLine(" Press [enter] to exit.");
Console.ReadLine();
}
}
);
worker.Start();
ISchedulerFactory schedFact = new StdSchedulerFactory();
// get a scheduler
IScheduler sched = schedFact.GetScheduler().Result;
sched.Start();
IJobDetail job = JobBuilder.Create <HelloJob>()
.WithIdentity("myJob", "group1")
.Build();
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("myTrigger", "group1")
.StartNow()
.WithSimpleSchedule(x => x
.WithIntervalInMinutes(1)
.RepeatForever())
.Build();
sched.ScheduleJob(job, trigger);
}
public override void OnLoggedOn(SteamUser.LoggedOnCallback callback)
{
switch (callback.Result)
{
case EResult.OK:
_log.Debug("Successfully logged in. Checking for any VAC or game bans...");
var banInfo = Titan.Instance.BanManager.GetBanInfoFor(_steamUser.SteamID.ConvertToUInt64());
if (banInfo != null && (banInfo.VacBanned || banInfo.GameBanCount > 0))
{
_log.Warning("The account has a ban on record. " +
"If the VAC/Game ban ban is from CS:GO, a {Mode} is not possible. " +
"Proceeding with caution.", _reportInfo != null ? "report" :"commend");
Result = Result.AccountBanned;
}
_log.Debug("Registering that we're playing CS:GO...");
_steamFriends.SetPersonaState(EPersonaState.Online);
var playGames = new ClientMsgProtobuf <CMsgClientGamesPlayed>(EMsg.ClientGamesPlayed);
if (_idleInfo != null)
{
foreach (var gameID in _idleInfo.GameID)
{
var gamesPlayed = new CMsgClientGamesPlayed.GamePlayed
{
game_id = Convert.ToUInt64(gameID)
};
if (gameID == 0)
{
gamesPlayed.game_extra_info = Titan.Instance.UIManager.GetForm <General>(UIType.General)
.CustomGameName;
}
playGames.Body.games_played.Add(gamesPlayed);
}
}
else
{
playGames.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed
{
game_id = 730
});
}
_steamClient.Send(playGames);
Thread.Sleep(5000);
if (_idleInfo == null)
{
_log.Debug("Successfully registered playing CS:GO. Sending client hello to CS:GO services.");
var clientHello =
new ClientGCMsgProtobuf <CMsgClientHello>((uint)EGCBaseClientMsg.k_EMsgGCClientHello);
_gameCoordinator.Send(clientHello, 730);
}
else
{
Trigger = TriggerBuilder.Create()
.WithIdentity("Idle Trigger - " + JsonAccount.Username + " (Unprotected)", "Titan")
.StartNow()
.WithSimpleSchedule(x => x
.WithIntervalInMinutes(_idleInfo.Minutes)
.WithRepeatCount(1))
.Build();
Titan.Instance.Scheduler.ScheduleJob(Job, Trigger);
_idleInfo.StartTick = DateTime.Now.Ticks;
_log.Debug("Successfully registered idling in requested games. Starting scheduler.");
}
break;
case EResult.AccountLoginDeniedNeedTwoFactor:
case EResult.AccountLogonDenied:
_log.Debug("Two Factor Authentification is activated on this account. Please set " +
"Sentry to {true} in the accounts.json for this account.", true);
Stop();
IsRunning = false;
Result = Result.SentryRequired;
break;
case EResult.InvalidPassword:
case EResult.NoConnection:
case EResult.Timeout:
case EResult.TryAnotherCM:
case EResult.TwoFactorCodeMismatch:
case EResult.ServiceUnavailable:
_log.Error("Unable to connect to Steam: {Reason}. Retrying...", callback.ExtendedResult);
break;
case EResult.RateLimitExceeded:
_log.Debug("Steam Rate Limit has been reached. Please try it again in a few minutes...");
Stop();
IsRunning = false;
Result = Result.RateLimit;
break;
case EResult.AccountDisabled:
_log.Error("This account has been permanently disabled by the Steam network.");
Stop();
IsRunning = false;
Result = Result.AccountBanned;
break;
default:
_log.Error("Unable to logon to account: {Result}: {ExtendedResult}", callback.Result, callback.ExtendedResult);
Stop();
IsRunning = false;
break;
}
}
public virtual async Task Run()
{
ILog log = LogProvider.GetLogger(typeof(LoadExample));
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = await sf.GetScheduler();
log.Info("------- Initialization Complete -----------");
log.Info("------- Scheduling Jobs -------------------");
Random r = new Random();
// schedule 500 jobs to run
for (int count = 1; count <= NumberOfJobs; count++)
{
IJobDetail job = JobBuilder
.Create <SimpleJob>()
.WithIdentity("job" + count, "group_1")
.RequestRecovery() // ask scheduler to re-execute this job if it was in progress when the scheduler went down...
.Build();
// tell the job to delay some small amount... to simulate work...
long timeDelay = (long)(r.NextDouble() * 2500);
job.JobDataMap.Put(SimpleJob.DelayTime, timeDelay);
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("trigger_" + count, "group_1")
.StartAt(DateBuilder.FutureDate((10000 + (count * 100)), IntervalUnit.Millisecond)) // space fire times a small bit
.Build();
await sched.ScheduleJob(job, trigger);
if (count % 25 == 0)
{
log.Info("...scheduled " + count + " jobs");
}
}
log.Info("------- Starting Scheduler ----------------");
// start the schedule
await sched.Start();
log.Info("------- Started Scheduler -----------------");
log.Info("------- Waiting five minutes... -----------");
// wait five minutes to give our jobs a chance to run
await Task.Delay(TimeSpan.FromMinutes(5));
// shut down the scheduler
log.Info("------- Shutting Down ---------------------");
await sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = await sched.GetMetaData();
log.Info("Executed " + metaData.NumberOfJobsExecuted + " jobs.");
}
private void StartPlan()
{
string xmlFile = base.Server.MapPath("/JobConfig.xml");
string nodeValue = XmlHelper.GetNodeValue(xmlFile, "JobName");
string str3 = XmlHelper.GetNodeValue(xmlFile, "JobGoup");
string str4 = XmlHelper.GetNodeValue(xmlFile, "CronSchedule");
this.sched = new StdSchedulerFactory().GetScheduler();
IJobDetail detail = JobBuilder.Create <Hidistro.UI.Web.Jobs.ShiftNotify>().WithIdentity(nodeValue, str3).Build();
ITrigger trigger = CronScheduleTriggerBuilderExtensions.WithCronSchedule(TriggerBuilder.Create().WithIdentity(nodeValue, str3), str4).Build();
this.sched.ScheduleJob(detail, trigger);
this.sched.Start();
}
private async Task InitJobAsync(IServiceScope scope)
{
using (scope)
{
var f = scope.ServiceProvider.GetRequiredService <ISingletonJobFactory>();
var now = DateTime.Now;
async Task ScheduleSaveRankeAsync(RankLevels level)
{
var jobIdentity = JobBuilder.Create <SaveRankJob>()
.WithIdentity(nameof(SaveRankJob) + level.ToString())
.RequestRecovery()
.Build();
TimeSpan rep = default;
DateTime startTime = default;
if (level == RankLevels.Hour)
{
rep = TimeSpan.FromHours(1);
startTime = new DateTime(now.Year, now.Month, now.Day, now.Hour, 1, 0).AddHours(1);
}
else if (level == RankLevels.Day)
{
rep = TimeSpan.FromDays(1);
startTime = new DateTime(now.Year, now.Month, now.Day, 0, 30, 0).AddDays(1);;
}
else if (level == RankLevels.Month)
{
rep = TimeSpan.FromDays(32);
startTime = new DateTime(now.Year, now.Month, 1, 1, 0, 0).AddMonths(1);
}
var trigger = TriggerBuilder.Create()
.StartAt(new DateTimeOffset(startTime))
.WithSimpleSchedule(b =>
{
b.WithInterval(rep).RepeatForever();
})
.Build();
var scheduler = await f.GetSchedulerAsync();
var offset = await scheduler.ScheduleJob(jobIdentity, trigger);
}
await ScheduleSaveRankeAsync(RankLevels.Hour);
await ScheduleSaveRankeAsync(RankLevels.Day);
await ScheduleSaveRankeAsync(RankLevels.Month);
var config = scope.ServiceProvider.GetRequiredService <IConfiguration>();
var syncInterval = config.GetValue <int>("BookshelfSync:IntervalS");
if (syncInterval <= 0)
{
syncInterval = 60 * 5;
}
var jobIdentity = JobBuilder.Create <StoreBookshelfJob>()
.WithIdentity(nameof(StoreBookshelfJob))
.RequestRecovery()
.Build();
var trigger = TriggerBuilder.Create()
.StartNow()
.WithSimpleSchedule(b =>
{
b.WithIntervalInSeconds(syncInterval).RepeatForever();
})
.Build();
var scheduler = await f.GetSchedulerAsync();
var offset = await scheduler.ScheduleJob(jobIdentity, trigger);
}
}
protected override async Task InitScheduler(IScheduler scheduler)
{
// construct job info
var jobDetail = JobBuilder.Create <HelloJob>()
.WithIdentity("myJob")
.StoreDurably()
.Build();
// fire every minute
var trigger = TriggerBuilder.Create()
.WithIdentity("myTrigger")
.StartNow()
.WithSimpleSchedule(x => x.WithIntervalInMinutes(1).RepeatForever())
.Build();
await scheduler.ScheduleJob(jobDetail, trigger).ConfigureAwait(false);
// construct job info
var jobDetail2 = JobBuilder.Create <HelloJob>()
.WithIdentity("myJob2")
.Build();
// fire every 3 minutes
var trigger2 = TriggerBuilder.Create()
.WithIdentity("myTrigger2")
.StartNow()
.WithSimpleSchedule(x => x.WithIntervalInMinutes(3))
.Build();
await scheduler.ScheduleJob(jobDetail2, trigger2).ConfigureAwait(false);
var trigger3 = TriggerBuilder.Create()
.WithIdentity("myTrigger3")
.ForJob(jobDetail2)
.StartNow()
.WithSimpleSchedule(x => x.WithIntervalInSeconds(2).RepeatForever())
//.WithSimpleSchedule(x => x.WithIntervalInMinutes(5).RepeatForever())
.Build();
await scheduler.ScheduleJob(trigger3).ConfigureAwait(false);
// construct job info
var jobDetail4 = JobBuilder.Create <HelloJob>()
.WithIdentity("myJob4", "MyOwnGroup")
.Build();
jobDetail4.JobDataMap.Add("key1", "value1");
jobDetail4.JobDataMap.Add("key2", "value2");
jobDetail4.JobDataMap.Add("key3", 1L);
jobDetail4.JobDataMap.Add("key4", 1d);
// fire every hour
ITrigger trigger4 = TriggerBuilder.Create()
.WithIdentity("myTrigger4", jobDetail4.Key.Group)
.StartNow()
.WithSimpleSchedule(x => x.WithIntervalInMinutes(1))
.Build();
ITrigger trigger5 = TriggerBuilder.Create()
.WithIdentity("myTrigger5", jobDetail4.Key.Group)
.StartNow()
.WithCronSchedule("0 0/5 * * * ?")
.Build();
await scheduler.ScheduleJob(jobDetail4, new ReadOnlyCollection <ITrigger>(new[] { trigger4, trigger5 }), false).ConfigureAwait(false);
// scheduler.ScheduleJob(jobDetail4, trigger5);
await scheduler.PauseJob(new JobKey("myJob4", "MyOwnGroup")).ConfigureAwait(false);
await scheduler.PauseTrigger(new TriggerKey("myTrigger3", "DEFAULT")).ConfigureAwait(false);
}
private static void ScheduleJobs()
{
int priority = Jobs.Count;
foreach (var tsk in Jobs.Where(x => x.TaskType == "S" && x.Status == "Queued")) // O - On Demand ; S- Scheduled.
{
var schedule = Schedules.FirstOrDefault(x => x.taskID == tsk.taskID);
var client = Machines.FirstOrDefault(x => x.ID == tsk.ClientID);
IJobDetail job = JobBuilder.Create <Job>().WithIdentity(tsk.TaskName, tsk.ClientID.ToString()).Build();
job.JobDataMap["command"] = tsk.Command;
job.JobDataMap["taskname"] = tsk.TaskName;
job.JobDataMap["TaskId"] = tsk.taskID;
if (client != null)
{
job.JobDataMap["remotepc"] = "\\\\" + client.HostName;
job.JobDataMap["username"] = client.Username;
job.JobDataMap["password"] = client.Password;
}
if (schedule != null)
{
TriggerBuilder tb = TriggerBuilder.Create();
tb.WithIdentity(tsk.TaskName);
if (schedule.repeatforever <= 0)
{
tb.WithSimpleSchedule(a => a.WithIntervalInHours(schedule.intHours));
tb.WithSimpleSchedule(a => a.WithIntervalInSeconds(schedule.intSec));
tb.WithSimpleSchedule(a => a.WithIntervalInMinutes(schedule.intMin));
}
else
{
if (schedule.intHours > 0)
{
tb.WithSimpleSchedule(a => a.WithIntervalInHours(schedule.intHours).RepeatForever());
}
if (schedule.intHours > 0)
{
tb.WithSimpleSchedule(a => a.WithIntervalInSeconds(schedule.intSec).RepeatForever());
}
if (schedule.intHours > 0)
{
tb.WithSimpleSchedule(a => a.WithIntervalInMinutes(schedule.intMin).RepeatForever());
}
}
if (schedule.startAt != null)
{
tb.StartAt(new DateTimeOffset((DateTime)schedule.startAt));
}
if (schedule.endAt != null)
{
tb.EndAt(new DateTimeOffset((DateTime)schedule.endAt));
}
tb.ForJob(job);
ITrigger trigger = tb.Build();
Scheduler.ScheduleJob(job, trigger);
}
}
}
public static void Main(string[] args)
{
Console.WriteLine("Task Scheduler Begins");
ISchedulerFactory schedFact = new StdSchedulerFactory();
// get a scheduler, start the schedular before triggers or anything else
IScheduler sched = schedFact.GetScheduler().Result;
sched.Start();
// create job
IJobDetail job = JobBuilder.Create <HelloWorldJob>()
.WithIdentity("job1", "group1")
.Build();
int option = 9;
HashSet <ITrigger> triggers = new HashSet <ITrigger>();
//ITrigger trigger = TriggerBuilder.Create().Build();
ITrigger trigger;
while (option != 4)
{
Console.Write("1. Fire an one time event base on a specific interval specified by the user. \n" +
"2. Fire events on a periodic interval(every 5, 10, 15, 20 minutes) using the top of the hour as the starting point. \n" +
"3. Fire events on specific days Monday, Wednesday and Friday at a specific times. \n" +
"4. Exit \n" +
"Enter Option: ");
#region User Input
bool tryAgain = true;
while (tryAgain)
{
try
{
option = Int32.Parse(Console.ReadLine());
tryAgain = false;
}
catch (System.FormatException e)
{
Console.WriteLine("Invalid input. Try again");
}
}
#endregion
switch (option)
{
case 1:
#region Case1
Console.WriteLine("Firing an event 2 seconds in the future (OR) at a specific time");
trigger = TriggerBuilder.Create()
.WithIdentity("trigger1", "group1")
.StartAt(DateTime.Now.AddSeconds(2))
.Build();
sched.ScheduleJob(job, trigger); // Schedule the job using the job and trigger
Console.ReadLine();
sched.UnscheduleJob(trigger.Key); // Unschedule job
break;
#endregion
case 2:
#region Case2
Console.WriteLine("Firing an event every 1 second. The trigger will begin after 2 seconds and will continue until 10 seconds from the start time. (Press ENTER key to stop)");
trigger = TriggerBuilder.Create()
.WithIdentity("trigger1", "group1")
.StartAt(DateTime.Now.AddSeconds(2))
.WithSimpleSchedule(x => x.WithIntervalInSeconds(1).RepeatForever())
.EndAt(DateTime.Now.AddSeconds(10))
.Build();
sched.ScheduleJob(job, trigger); // Schedule the job using the job and trigger
Console.ReadLine();
sched.UnscheduleJob(trigger.Key); // Unschedule job
break;
#endregion
case 3:
#region Case3
// Scheduling events using CRON expressions
Console.WriteLine("Fire events on specific days Monday, Wednesday and Friday at a specific times. (Press ENTER key to stop)");
trigger = TriggerBuilder.Create()
.WithIdentity("trigger1", "group1")
.StartAt(DateTime.Now)
.WithCronSchedule("0/30 55-59 12 ? * TUE,WED")
.Build();
triggers.Add(trigger);
trigger = TriggerBuilder.Create()
.WithIdentity("trigger2", "group1")
.StartAt(DateTime.Now)
.WithCronSchedule("0/7 56-59 12 ? * TUE,THU")
.Build();
triggers.Add(trigger);
trigger = TriggerBuilder.Create()
.WithIdentity("trigger3", "group1")
.StartAt(DateTime.Now)
.WithCronSchedule("0/10 57-49 12 ? * THU,FRI")
.Build();
triggers.Add(trigger);
sched.ScheduleJob(job, triggers, false); // Schedule the job using the job and trigger list
Console.ReadLine();
sched.UnscheduleJobs(triggers.Select(x => x.Key).ToList()); // Unschedule all jobs associated with the triggers
break;
#endregion
}
}
}
/// <summary>
/// How to compatible old code to SilkierQuartz
/// </summary>
/// <param name="app"></param>
public static void SchedulerJobs(this IApplicationBuilder app)
{
IScheduler scheduler = app.GetScheduler();
{
var jobData = new JobDataMap();
jobData.Put("DateFrom", DateTime.Now);
jobData.Put("QuartzAssembly", File.ReadAllBytes(typeof(IScheduler).Assembly.Location));
var job = JobBuilder.Create <DummyJob>()
.WithIdentity("Sales", "REPORTS")
.WithDescription("Hello Job!")
.UsingJobData(jobData)
.StoreDurably()
.Build();
var trigger = TriggerBuilder.Create()
.WithIdentity("MorningSales")
.StartNow()
.WithCronSchedule("0 0 8 1/1 * ? *")
.Build();
if (!scheduler.CheckExists(job.Key).GetAwaiter().GetResult())
{
scheduler.ScheduleJob(job, trigger).Wait();
}
trigger = TriggerBuilder.Create()
.WithIdentity("MonthlySales")
.ForJob(job.Key)
.StartNow()
.WithCronSchedule("0 0 12 1 1/1 ? *")
.Build();
if (!scheduler.CheckExists(trigger.Key).GetAwaiter().GetResult())
{
scheduler.ScheduleJob(trigger).Wait();;
}
scheduler.PauseTrigger(trigger.Key).Wait();;
trigger = TriggerBuilder.Create()
.WithIdentity("HourlySales")
.ForJob(job.Key)
.StartNow()
.WithSimpleSchedule(x => x.WithIntervalInHours(1).RepeatForever())
.Build();
if (!scheduler.CheckExists(trigger.Key).GetAwaiter().GetResult())
{
scheduler.ScheduleJob(trigger).Wait();;
}
}
Task.Run(async() =>
{
var job = JobBuilder.Create <DummyJob>().WithIdentity("Job1").StoreDurably().Build();
await scheduler.AddJob(job, false);
job = JobBuilder.Create <DummyJob>().WithIdentity("Job2").StoreDurably().Build();
await scheduler.AddJob(job, false);
job = JobBuilder.Create <DummyJob>().WithIdentity("Job3").StoreDurably().Build();
await scheduler.AddJob(job, false);
job = JobBuilder.Create <DummyJob>().WithIdentity("Job4").StoreDurably().Build();
await scheduler.AddJob(job, false);
job = JobBuilder.Create <DummyJob>().WithIdentity("Job5").StoreDurably().Build();
await scheduler.AddJob(job, false);
job = JobBuilder.Create <DummyJob>().WithIdentity("Send SMS", "CRITICAL").StoreDurably().RequestRecovery().Build();
await scheduler.AddJob(job, false);
var trigger = TriggerBuilder.Create()
.WithIdentity("PushAds (US)")
.ForJob(job.Key)
.UsingJobData("Location", "US")
.StartNow()
.WithCronSchedule("0 0/5 * 1/1 * ? *")
.Build();
await scheduler.ScheduleJob(trigger);
trigger = TriggerBuilder.Create()
.WithIdentity("PushAds (EU)")
.ForJob(job.Key)
.UsingJobData("Location", "EU")
.StartNow()
.WithCronSchedule("0 0/7 * 1/1 * ? *")
.Build();
await scheduler.ScheduleJob(trigger);
await scheduler.PauseTriggers(GroupMatcher <TriggerKey> .GroupEquals("LONGRUNNING"));
job = JobBuilder.Create <DummyJob>().WithIdentity("Send Push", "CRITICAL").StoreDurably().RequestRecovery().Build();
await scheduler.AddJob(job, false);
});
Task.Run(async() =>
{
var job = JobBuilder.Create <DisallowConcurrentJob>()
.WithIdentity("Load CSV", "IMPORT")
.StoreDurably()
.Build();
var trigger = TriggerBuilder.Create()
.WithIdentity("CSV_small", "FREQUENTLY")
.ForJob(job)
.StartNow()
.WithSimpleSchedule(x => x.WithIntervalInSeconds(5).RepeatForever())
.Build();
await scheduler.ScheduleJob(job, trigger);
trigger = TriggerBuilder.Create()
.WithIdentity("CSV_big", "LONGRUNNING")
.ForJob(job)
.StartNow()
.WithDailyTimeIntervalSchedule(x => x.OnMondayThroughFriday())
.Build();
await scheduler.ScheduleJob(trigger);
});
}
/// <summary>
/// ��������
/// </summary>
/// <param name="entity"></param>
/// <param name="start">�Ƿ���������</param>
/// <returns></returns>
private async Task <IResultModel> AddJob(JobEntity entity, bool start = false)
{
var jobClassType = Type.GetType(entity.JobClass);
if (jobClassType == null)
{
return(ResultModel.Failed($"������({entity.JobClass})������"));
}
var jobKey = new JobKey(entity.Code, entity.Group);
var job = JobBuilder.Create(jobClassType).WithIdentity(jobKey).UsingJobData("id", entity.Id.ToString()).Build();
var triggerBuilder = TriggerBuilder.Create().WithIdentity(entity.Code, entity.Group)
.EndAt(entity.EndDate.ToUniversalTime())
.WithDescription(entity.Name);
//�����ʼ����С�ڵ��ڵ�ǰ��������������
if (entity.BeginDate <= DateTime.Now)
{
triggerBuilder.StartNow();
}
else
{
triggerBuilder.StartAt(entity.BeginDate.ToUniversalTime());
}
if (entity.TriggerType == TriggerType.Simple)
{
//������
triggerBuilder.WithSimpleSchedule(builder =>
{
builder.WithIntervalInSeconds(entity.Interval);
if (entity.RepeatCount > 0)
{
builder.WithRepeatCount(entity.RepeatCount - 1);
}
else
{
builder.RepeatForever();
}
});
}
else
{
if (!CronExpression.IsValidExpression(entity.Cron))
{
return(ResultModel.Failed("CRON����ʽ��Ч"));
}
//CRON����
triggerBuilder.WithCronSchedule(entity.Cron);
}
var trigger = triggerBuilder.Build();
try
{
await _quartzServer.AddJob(job, trigger);
if (!start)
{
//����ͣ
await _quartzServer.PauseJob(jobKey);
}
return(ResultModel.Success());
}
catch (Exception ex)
{
_logger.LogError("���������������ʧ��" + ex);
}
return(ResultModel.Failed());
}
private IScheduler CreateScheduler()
{
var schedulerFactory = new StdSchedulerFactory();
var scheduler = schedulerFactory.GetScheduler();
// construct job info
var jobDetail = JobBuilder.Create <HelloJob>()
.WithIdentity("myJob")
.StoreDurably()
.Build();
// fire every minute
var trigger = TriggerBuilder.Create()
.WithIdentity("myTrigger")
.StartNow()
.WithSimpleSchedule(x => x.WithIntervalInMinutes(1).RepeatForever().WithMisfireHandlingInstructionNextWithRemainingCount())
.Build();
scheduler.ScheduleJob(jobDetail, trigger);
// construct job info
var jobDetail2 = JobBuilder.Create <HelloJob>()
.WithIdentity("myJob2")
.Build();
// fire every 3 minutes
var trigger2 = TriggerBuilder.Create()
.WithIdentity("myTrigger2")
.StartNow()
.WithSimpleSchedule(x => x.WithIntervalInMinutes(3).WithMisfireHandlingInstructionIgnoreMisfires())
.Build();
scheduler.ScheduleJob(jobDetail2, trigger2);
var trigger3 = TriggerBuilder.Create()
.WithIdentity("myTrigger3")
.ForJob(jobDetail2)
.StartNow()
.WithSimpleSchedule(x => x.WithIntervalInSeconds(2).RepeatForever())
//.WithSimpleSchedule(x => x.WithIntervalInMinutes(5).RepeatForever())
.Build();
scheduler.ScheduleJob(trigger3);
// construct job info
var jobDetail4 = JobBuilder.Create <HelloJob>()
.WithIdentity("myJob4", "MyOwnGroup")
.Build();
jobDetail4.JobDataMap.Add("key1", "value1");
jobDetail4.JobDataMap.Add("key2", "value2");
jobDetail4.JobDataMap.Add("key3", 1L);
jobDetail4.JobDataMap.Add("key4", 1d);
jobDetail4.JobDataMap.Add("key5", new[]
{
"Test1",
"Test2",
"Test3"
});
jobDetail4.JobDataMap.Add("key6", new { FirstName = "John", LastName = "Smith", BirthDate = new DateTime(2011, 03, 08) });
// fire every hour
ITrigger trigger4 = TriggerBuilder.Create()
.WithIdentity("myTrigger4", jobDetail4.Key.Group)
.StartNow()
.WithSimpleSchedule(x => x.WithIntervalInMinutes(1))
.Build();
ITrigger trigger5 = TriggerBuilder.Create()
.WithIdentity("myTrigger5", jobDetail4.Key.Group)
.StartNow()
.WithCronSchedule("0 0/5 * * * ?")
.Build();
scheduler.ScheduleJob(jobDetail4, new HashSet <ITrigger>(new[] { trigger4, trigger5 }), false);
// scheduler.ScheduleJob(jobDetail4, trigger5);
scheduler.PauseJob(new JobKey("myJob4", "MyOwnGroup"));
scheduler.PauseTrigger(new TriggerKey("myTrigger3", "DEFAULT"));
scheduler.Start();
return(scheduler);
}
public virtual async Task Run()
{
ILog log = LogProvider.GetLogger(typeof(JobStateExample));
log.Info("------- Initializing -------------------");
// First we must get a reference to a scheduler
var properties = new NameValueCollection
{
["quartz.serializer.type"] = "json"
};
ISchedulerFactory sf = new StdSchedulerFactory(properties);
IScheduler sched = await sf.GetScheduler();
log.Info("------- Initialization Complete --------");
log.Info("------- Scheduling Jobs ----------------");
// get a "nice round" time a few seconds in the future....
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 10);
// job1 will only run 5 times (at start time, plus 4 repeats), every 10 seconds
IJobDetail job1 = JobBuilder.Create <ColorJob>()
.WithIdentity("job1", "group1")
.Build();
ISimpleTrigger trigger1 = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger1", "group1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(10).WithRepeatCount(4))
.Build();
// pass initialization parameters into the job
job1.JobDataMap.Put(ColorJob.FavoriteColor, "Green");
job1.JobDataMap.Put(ColorJob.ExecutionCount, 1);
// schedule the job to run
DateTimeOffset scheduleTime1 = await sched.ScheduleJob(job1, trigger1);
log.Info($"{job1.Key} will run at: {scheduleTime1.ToString("r")} and repeat: {trigger1.RepeatCount} times, every {trigger1.RepeatInterval.TotalSeconds} seconds");
// job2 will also run 5 times, every 10 seconds
IJobDetail job2 = JobBuilder.Create <ColorJob>()
.WithIdentity("job2", "group1")
.Build();
ISimpleTrigger trigger2 = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger2", "group1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(10).WithRepeatCount(4))
.Build();
// pass initialization parameters into the job
// this job has a different favorite color!
job2.JobDataMap.Put(ColorJob.FavoriteColor, "Red");
job2.JobDataMap.Put(ColorJob.ExecutionCount, 1);
// schedule the job to run
DateTimeOffset scheduleTime2 = await sched.ScheduleJob(job2, trigger2);
log.Info($"{job2.Key} will run at: {scheduleTime2.ToString("r")} and repeat: {trigger2.RepeatCount} times, every {trigger2.RepeatInterval.TotalSeconds} seconds");
log.Info("------- Starting Scheduler ----------------");
// All of the jobs have been added to the scheduler, but none of the jobs
// will run until the scheduler has been started
await sched.Start();
log.Info("------- Started Scheduler -----------------");
log.Info("------- Waiting 60 seconds... -------------");
// wait five minutes to show jobs
await Task.Delay(TimeSpan.FromMinutes(5));
// executing...
log.Info("------- Shutting Down ---------------------");
await sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = await sched.GetMetaData();
log.Info($"Executed {metaData.NumberOfJobsExecuted} jobs.");
}
/// <summary>
/// Executes this instance.
/// </summary>
public void Execute()
{
using (var rockContext = new RockContext())
{
var jobService = new ServiceJobService(rockContext);
ServiceJob job = jobService.Get(JobId);
if (job != null)
{
try
{
// create a scheduler specific for the job
var scheduleConfig = new System.Collections.Specialized.NameValueCollection();
var runNowSchedulerName = ("RunNow:" + job.Guid.ToString("N")).Truncate(40);
scheduleConfig.Add(StdSchedulerFactory.PropertySchedulerInstanceName, runNowSchedulerName);
var schedulerFactory = new StdSchedulerFactory(scheduleConfig);
var sched = new StdSchedulerFactory(scheduleConfig).GetScheduler();
if (sched.IsStarted)
{
// the job is currently running as a RunNow job
return;
}
// create the quartz job and trigger
IJobDetail jobDetail = jobService.BuildQuartzJob(job);
var jobTrigger = TriggerBuilder.Create()
.WithIdentity(job.Guid.ToString(), job.Name)
.StartNow()
.Build();
// schedule the job
sched.ScheduleJob(jobDetail, jobTrigger);
// set up the listener to report back from the job when it completes
sched.ListenerManager.AddJobListener(new RockJobListener(), EverythingMatcher <JobKey> .AllJobs());
// start the scheduler
sched.Start();
// Wait 10secs to give job chance to start
System.Threading.Tasks.Task.Delay(new TimeSpan(0, 0, 10)).Wait();
// stop the scheduler when done with job
sched.Shutdown(true);
}
catch (Exception ex)
{
// create a friendly error message
ExceptionLogService.LogException(ex, null);
string message = string.Format("Error doing a 'Run Now' on job: {0}. \n\n{2}", job.Name, job.Assembly, ex.Message);
job.LastStatusMessage = message;
job.LastStatus = "Error Loading Job";
rockContext.SaveChanges();
var jobHistoryService = new ServiceJobHistoryService(rockContext);
var jobHistory = new ServiceJobHistory()
{
ServiceJobId = job.Id,
StartDateTime = RockDateTime.Now,
StopDateTime = RockDateTime.Now,
Status = job.LastStatus,
StatusMessage = job.LastStatusMessage
};
jobHistoryService.Add(jobHistory);
rockContext.SaveChanges();
}
}
}
}
internal MonthlyTriggerBuilder(BuilderInfo taskBuilder, MonthsOfTheYear moy)
: base(taskBuilder)
{
this.trb = new TriggerBuilder(taskBuilder, moy);
}
public async Task <string> Start(List <string> param)
{
// string SqlLiteConn = RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? "Data Source=Db/LogData.dll;" : "Data Source=Db\\LogData.dll;";
// using (var logW = new FreeSqlBuilder()
//.UseConnectionFactory(FreeSql.DataType.Sqlite, () => new System.Data.SQLite.SQLiteConnection(SqlLiteConn))
// .UseAutoSyncStructure(false)
// .Build())
// {
// var logs = new List<Logs>();
// for (int i = 0; i < 100000; i++)
// {
// logs.Add(new Logs
// {
// Application = "test",
// EventId = "test",
// Level = "test",
// Logger = "freesqlLogger",
// Message = i.ToString() + "当前线程id" + Thread.CurrentThread.ManagedThreadId,
// TimestampUtc = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")
// });
// }
// _ = logW.Insert(logs).NoneParameter(true).ExecuteAffrows();
// logs = null;
// }
// return "";
// await LogDela();
//return await Task.FromResult($"开启失败，失败原因");
try
{
int Second = 0;
if (param.Count > 1 && _scheduler != null)
{
await Stop();
}
for (int i = 0; i < param.Count; i++)
{
//计算出事件的秒数
var ts = await _sqliteFSql.Select <TaskPlan>().Where(o => o.GUID == param[i]).FirstAsync();
switch (ts.FrequencyType)
{
case "0":
Second = int.Parse(ts.Frequency);
break;
case "1":
Second = int.Parse(ts.Frequency) * 60;
break;
case "2":
Second = int.Parse(ts.Frequency) * 3600;
break;
default:
break;
}
//2、通过调度工厂获得调度器
_scheduler = await _schedulerFactory.GetScheduler();
_scheduler.JobFactory = this._iocJobfactory;
// 替换默认工厂
//3、开启调度器
_logger.LogInformation("定时任务({EventId})启动", ts.Name);
await _scheduler.Start();
//4、创建一个触发器
var trigger = TriggerBuilder.Create()
.WithSimpleSchedule(x => x.WithIntervalInSeconds(Second).RepeatForever())
.Build();
IJobDetail jobDetail;
//5、创建任务 0是dll 模式 1是api模式
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
if (rds.ContainsKey(param[i].ToString()))
{
return(await Task.FromResult($"已经开启过任务{ts.Name}不允许重复开启！"));
}
if (ts.WorkType == "0")
{
jobDetail = JobBuilder.Create <AutoTaskJobDll>()
.WithIdentity(param[i].ToString(), "group")
.UsingJobData("guid", param[i].ToString())
.Build();
}
else
{
jobDetail = JobBuilder.Create <AutoTaskJob>()
.WithIdentity(param[i].ToString(), "group")
.UsingJobData("guid", param[i].ToString())
.Build();
}
rds.Set(param[i].ToString(), jobDetail.Key);
}
else
{
if (ts.Status == "1" || jobKeys.ContainsKey(param[i].ToString()))
{
return(await Task.FromResult($"已经开启过任务{ts.Name}不允许重复开启！"));
}
else
{
if (ts.WorkType == "0")
{
jobDetail = JobBuilder.Create <AutoTaskJobDll>()
.WithIdentity(param[i].ToString(), "group")
.UsingJobData("guid", param[i].ToString())
.Build();
}
else
{
jobDetail = JobBuilder.Create <AutoTaskJob>()
.WithIdentity(param[i].ToString(), "group")
.UsingJobData("guid", param[i].ToString())
.Build();
}
ts.Status = "1";
_sqliteFSql.Update <TaskPlan>()
.Set(a => a.Status, ts.Status)
.Where(a => a.GUID == ts.GUID)
.ExecuteAffrows();
jobKeys.Add(param[i].ToString(), jobDetail.Key);
}
}
//6、将触发器和任务器绑定到调度器中
await _scheduler.ScheduleJob(jobDetail, trigger);
}
// return await Task.FromResult("0");
return("0");
}
catch (Exception ex)
{
_logger.LogError($"开启失败，失败原因:{ex.Message}");
//return await Task.FromResult($"开启失败，失败原因:{ex.Message}");
return($"开启失败，失败原因:{ex.Message}");
}
}
/// <summary>
/// Application specific configuration
/// This method should initialize any IoC resources utilized by your web service classes.
/// </summary>
/// <param name="container"></param>
public override void Configure(Container container)
{
SetConfig(new HostConfig {
DebugMode = AppSettings.Get("DebugMode", Env.IsWindows),
});
// override config
var quartzConfig = ConfigureQuartz();
// register plugin, will scan assemblies by default for jobs
var quartzFeature = new QuartzFeature();
Plugins.Add(quartzFeature);
Plugins.Add(new PostmanFeature());
// or you can register the plugin with custom config source
Plugins.AddIfNotExists(new QuartzFeature {
Config = quartzConfig
});
// or you can register plugin with custom job assemblies
Plugins.AddIfNotExists(new QuartzFeature
{
ScanAppHostAssemblies = false,
JobAssemblies = new[] { typeof(HelloJob).Assembly, typeof(AppHost).Assembly }
});
// now you can setup a job to run with a trigger
quartzFeature.RegisterJob <HelloJob>(
trigger =>
trigger.WithSimpleSchedule(s =>
s.WithInterval(TimeSpan.FromMinutes(1))
.RepeatForever()
)
.Build()
);
// or setup a job to run with a trigger and some data
quartzFeature.RegisterJob <HelloJob>(
trigger =>
trigger.WithSimpleSchedule(s =>
s.WithIntervalInMinutes(1)
.WithRepeatCount(10)
)
.Build(),
builder => builder.UsingJobData("Name", "Bob").Build()
);
// cron schedule trigger
var cronTrigger = TriggerBuilder.Create()
.WithCronSchedule("0 0 0/1 1/1 * ? *")
.Build();
quartzFeature.RegisterJob <HelloJob>(cronTrigger);
// you can setup jobs with data and triggers however you like
// this lets create a trigger with our preferred identity
var everyHourTrigger = TriggerBuilder.Create()
.WithDescription("This is my trigger!")
.WithIdentity("everyHour", "Continuous")
.WithDailyTimeIntervalSchedule(x => x.OnMondayThroughFriday().WithIntervalInHours(1))
.Build();
var jobData = JobBuilder.Create <HelloJob>().UsingJobData("Name", "Sharon").Build();
quartzFeature.RegisterJob <HelloJob>(everyHourTrigger);
quartzFeature.RegisterJob <HelloJob>(everyHourTrigger, jobData);
}
private void ScheduleWorkflow(Workflow wf)
{
if (wf.IsEnabled)
{
if (wf.LaunchType == LaunchType.Startup)
{
wf.Start();
}
else if (wf.LaunchType == LaunchType.Periodic)
{
IDictionary <string, object> map = new Dictionary <string, object>();
map.Add("workflow", wf);
string jobIdentity = "Workflow Job " + wf.Id;
IJobDetail jobDetail = JobBuilder.Create <WorkflowJob>()
.WithIdentity(jobIdentity)
.SetJobData(new JobDataMap(map))
.Build();
ITrigger trigger = TriggerBuilder.Create()
.ForJob(jobDetail)
.WithSimpleSchedule(x => x.WithInterval(wf.Period).RepeatForever())
.WithIdentity("Workflow Trigger " + wf.Id)
.StartNow()
.Build();
var jobKey = new JobKey(jobIdentity);
if (QuartzScheduler.CheckExists(jobKey))
{
QuartzScheduler.DeleteJob(jobKey);
}
QuartzScheduler.ScheduleJob(jobDetail, trigger);
}
else if (wf.LaunchType == LaunchType.Cron)
{
IDictionary <string, object> map = new Dictionary <string, object>();
map.Add("workflow", wf);
string jobIdentity = "Workflow Job " + wf.Id;
IJobDetail jobDetail = JobBuilder.Create <WorkflowJob>()
.WithIdentity(jobIdentity)
.SetJobData(new JobDataMap(map))
.Build();
ITrigger trigger = TriggerBuilder.Create()
.ForJob(jobDetail)
.WithCronSchedule(wf.CronExpression)
.WithIdentity("Workflow Trigger " + wf.Id)
.StartNow()
.Build();
var jobKey = new JobKey(jobIdentity);
if (QuartzScheduler.CheckExists(jobKey))
{
QuartzScheduler.DeleteJob(jobKey);
}
QuartzScheduler.ScheduleJob(jobDetail, trigger);
}
}
}
public virtual async Task Run()
{
ILog log = LogProvider.GetLogger(typeof(SimpleTriggerExample));
log.Info("------- Initializing -------------------");
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = await sf.GetScheduler();
log.Info("------- Initialization Complete --------");
log.Info("------- Scheduling Jobs ----------------");
// jobs can be scheduled before sched.start() has been called
// get a "nice round" time a few seconds in the future...
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 15);
// job1 will only fire once at date/time "ts"
IJobDetail job = JobBuilder.Create <SimpleJob>()
.WithIdentity("job1", "group1")
.Build();
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger1", "group1")
.StartAt(startTime)
.Build();
// schedule it to run!
DateTimeOffset?ft = await sched.ScheduleJob(job, trigger);
log.Info(job.Key +
" will run at: " + ft +
" and repeat: " + trigger.RepeatCount +
" times, every " + trigger.RepeatInterval.TotalSeconds + " seconds");
// job2 will only fire once at date/time "ts"
job = JobBuilder.Create <SimpleJob>()
.WithIdentity("job2", "group1")
.Build();
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger2", "group1")
.StartAt(startTime)
.Build();
ft = await sched.ScheduleJob(job, trigger);
log.Info(job.Key +
" will run at: " + ft +
" and repeat: " + trigger.RepeatCount +
" times, every " + trigger.RepeatInterval.TotalSeconds + " seconds");
// job3 will run 11 times (run once and repeat 10 more times)
// job3 will repeat every 10 seconds
job = JobBuilder.Create <SimpleJob>()
.WithIdentity("job3", "group1")
.Build();
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger3", "group1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(10).WithRepeatCount(10))
.Build();
ft = await sched.ScheduleJob(job, trigger);
log.Info(job.Key +
" will run at: " + ft +
" and repeat: " + trigger.RepeatCount +
" times, every " + trigger.RepeatInterval.TotalSeconds + " seconds");
// the same job (job3) will be scheduled by a another trigger
// this time will only repeat twice at a 70 second interval
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger3", "group2")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(10).WithRepeatCount(2))
.ForJob(job)
.Build();
ft = await sched.ScheduleJob(trigger);
log.Info(job.Key +
" will [also] run at: " + ft +
" and repeat: " + trigger.RepeatCount +
" times, every " + trigger.RepeatInterval.TotalSeconds + " seconds");
// job4 will run 6 times (run once and repeat 5 more times)
// job4 will repeat every 10 seconds
job = JobBuilder.Create <SimpleJob>()
.WithIdentity("job4", "group1")
.Build();
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger4", "group1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(10).WithRepeatCount(5))
.Build();
ft = await sched.ScheduleJob(job, trigger);
log.Info(job.Key +
" will run at: " + ft +
" and repeat: " + trigger.RepeatCount +
" times, every " + trigger.RepeatInterval.TotalSeconds + " seconds");
// job5 will run once, five minutes in the future
job = JobBuilder.Create <SimpleJob>()
.WithIdentity("job5", "group1")
.Build();
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger5", "group1")
.StartAt(DateBuilder.FutureDate(5, IntervalUnit.Minute))
.Build();
ft = await sched.ScheduleJob(job, trigger);
log.Info(job.Key +
" will run at: " + ft +
" and repeat: " + trigger.RepeatCount +
" times, every " + trigger.RepeatInterval.TotalSeconds + " seconds");
// job6 will run indefinitely, every 40 seconds
job = JobBuilder.Create <SimpleJob>()
.WithIdentity("job6", "group1")
.Build();
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger6", "group1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(40).RepeatForever())
.Build();
ft = await sched.ScheduleJob(job, trigger);
log.Info(job.Key +
" will run at: " + ft +
" and repeat: " + trigger.RepeatCount +
" times, every " + trigger.RepeatInterval.TotalSeconds + " seconds");
log.Info("------- Starting Scheduler ----------------");
// All of the jobs have been added to the scheduler, but none of the jobs
// will run until the scheduler has been started
await sched.Start();
log.Info("------- Started Scheduler -----------------");
// jobs can also be scheduled after start() has been called...
// job7 will repeat 20 times, repeat every five minutes
job = JobBuilder.Create <SimpleJob>()
.WithIdentity("job7", "group1")
.Build();
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger7", "group1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInMinutes(5).WithRepeatCount(20))
.Build();
ft = await sched.ScheduleJob(job, trigger);
log.Info(job.Key +
" will run at: " + ft +
" and repeat: " + trigger.RepeatCount +
" times, every " + trigger.RepeatInterval.TotalSeconds + " seconds");
// jobs can be fired directly... (rather than waiting for a trigger)
job = JobBuilder.Create <SimpleJob>()
.WithIdentity("job8", "group1")
.StoreDurably()
.Build();
await sched.AddJob(job, true);
log.Info("'Manually' triggering job8...");
await sched.TriggerJob(new JobKey("job8", "group1"));
log.Info("------- Waiting 30 seconds... --------------");
try
{
// wait 30 seconds to show jobs
await Task.Delay(TimeSpan.FromSeconds(30));
// executing...
}
catch (ThreadInterruptedException)
{
}
// jobs can be re-scheduled...
// job 7 will run immediately and repeat 10 times for every second
log.Info("------- Rescheduling... --------------------");
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger7", "group1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInMinutes(5).WithRepeatCount(20))
.Build();
ft = await sched.RescheduleJob(trigger.Key, trigger);
log.Info("job7 rescheduled to run at: " + ft);
log.Info("------- Waiting five minutes... ------------");
// wait five minutes to show jobs
await Task.Delay(TimeSpan.FromMinutes(5));
// executing...
log.Info("------- Shutting Down ---------------------");
await sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
// display some stats about the schedule that just ran
SchedulerMetaData metaData = await sched.GetMetaData();
log.Info($"Executed {metaData.NumberOfJobsExecuted} jobs.");
}
protected virtual void ProcessInternal(string xml)
{
PrepForProcessing();
#if XML_SCHEMA
ValidateXml(xml);
#endif // XML_SCHEMA
MaybeThrowValidationException();
// deserialize as object model
XmlSerializer xs = new XmlSerializer(typeof(QuartzXmlConfiguration20));
QuartzXmlConfiguration20 data = (QuartzXmlConfiguration20)xs.Deserialize(new StringReader(xml));
if (data == null)
{
throw new SchedulerConfigException("Job definition data from XML was null after deserialization");
}
//
// Extract pre-processing commands
//
if (data.preprocessingcommands != null)
{
foreach (preprocessingcommandsType command in data.preprocessingcommands)
{
if (command.deletejobsingroup != null)
{
foreach (string s in command.deletejobsingroup)
{
string deleteJobGroup = s.NullSafeTrim();
if (!string.IsNullOrEmpty(deleteJobGroup))
{
jobGroupsToDelete.Add(deleteJobGroup);
}
}
}
if (command.deletetriggersingroup != null)
{
foreach (string s in command.deletetriggersingroup)
{
string deleteTriggerGroup = s.NullSafeTrim();
if (!string.IsNullOrEmpty(deleteTriggerGroup))
{
triggerGroupsToDelete.Add(deleteTriggerGroup);
}
}
}
if (command.deletejob != null)
{
foreach (preprocessingcommandsTypeDeletejob s in command.deletejob)
{
string name = s.name.TrimEmptyToNull();
string group = s.group.TrimEmptyToNull();
if (name == null)
{
throw new SchedulerConfigException("Encountered a 'delete-job' command without a name specified.");
}
jobsToDelete.Add(new JobKey(name, group));
}
}
if (command.deletetrigger != null)
{
foreach (preprocessingcommandsTypeDeletetrigger s in command.deletetrigger)
{
string name = s.name.TrimEmptyToNull();
string group = s.group.TrimEmptyToNull();
if (name == null)
{
throw new SchedulerConfigException("Encountered a 'delete-trigger' command without a name specified.");
}
triggersToDelete.Add(new TriggerKey(name, group));
}
}
}
}
if (Log.IsDebugEnabled())
{
Log.Debug("Found " + jobGroupsToDelete.Count + " delete job group commands.");
Log.Debug("Found " + triggerGroupsToDelete.Count + " delete trigger group commands.");
Log.Debug("Found " + jobsToDelete.Count + " delete job commands.");
Log.Debug("Found " + triggersToDelete.Count + " delete trigger commands.");
}
//
// Extract directives
//
if (data.processingdirectives != null && data.processingdirectives.Length > 0)
{
bool overWrite = data.processingdirectives[0].overwriteexistingdata;
Log.Debug("Directive 'overwrite-existing-data' specified as: " + overWrite);
OverWriteExistingData = overWrite;
}
else
{
Log.Debug("Directive 'overwrite-existing-data' not specified, defaulting to " + OverWriteExistingData);
}
if (data.processingdirectives != null && data.processingdirectives.Length > 0)
{
bool ignoreduplicates = data.processingdirectives[0].ignoreduplicates;
Log.Debug("Directive 'ignore-duplicates' specified as: " + ignoreduplicates);
IgnoreDuplicates = ignoreduplicates;
}
else
{
Log.Debug("Directive 'ignore-duplicates' not specified, defaulting to " + IgnoreDuplicates);
}
if (data.processingdirectives != null && data.processingdirectives.Length > 0)
{
bool scheduleRelative = data.processingdirectives[0].scheduletriggerrelativetoreplacedtrigger;
Log.Debug("Directive 'schedule-trigger-relative-to-replaced-trigger' specified as: " + scheduleRelative);
ScheduleTriggerRelativeToReplacedTrigger = scheduleRelative;
}
else
{
Log.Debug("Directive 'schedule-trigger-relative-to-replaced-trigger' not specified, defaulting to " + ScheduleTriggerRelativeToReplacedTrigger);
}
//
// Extract Job definitions...
//
List <jobdetailType> jobNodes = new List <jobdetailType>();
if (data.schedule != null)
{
foreach (var schedule in data.schedule)
{
if (schedule?.job != null)
{
jobNodes.AddRange(schedule.job);
}
}
}
Log.Debug("Found " + jobNodes.Count + " job definitions.");
foreach (jobdetailType jobDetailType in jobNodes)
{
string jobName = jobDetailType.name.TrimEmptyToNull();
string jobGroup = jobDetailType.group.TrimEmptyToNull();
string jobDescription = jobDetailType.description.TrimEmptyToNull();
string jobTypeName = jobDetailType.jobtype.TrimEmptyToNull();
bool jobDurability = jobDetailType.durable;
bool jobRecoveryRequested = jobDetailType.recover;
Type jobType = TypeLoadHelper.LoadType(jobTypeName);
IJobDetail jobDetail = JobBuilder.Create(jobType)
.WithIdentity(jobName, jobGroup)
.WithDescription(jobDescription)
.StoreDurably(jobDurability)
.RequestRecovery(jobRecoveryRequested)
.Build();
if (jobDetailType.jobdatamap != null && jobDetailType.jobdatamap.entry != null)
{
foreach (entryType entry in jobDetailType.jobdatamap.entry)
{
string key = entry.key.TrimEmptyToNull();
string value = entry.value.TrimEmptyToNull();
jobDetail.JobDataMap.Add(key, value);
}
}
if (Log.IsDebugEnabled())
{
Log.Debug("Parsed job definition: " + jobDetail);
}
AddJobToSchedule(jobDetail);
}
//
// Extract Trigger definitions...
//
List <triggerType> triggerEntries = new List <triggerType>();
if (data.schedule != null)
{
foreach (var schedule in data.schedule)
{
if (schedule != null && schedule.trigger != null)
{
triggerEntries.AddRange(schedule.trigger);
}
}
}
Log.Debug("Found " + triggerEntries.Count + " trigger definitions.");
foreach (triggerType triggerNode in triggerEntries)
{
string triggerName = triggerNode.Item.name.TrimEmptyToNull();
string triggerGroup = triggerNode.Item.group.TrimEmptyToNull();
string triggerDescription = triggerNode.Item.description.TrimEmptyToNull();
string triggerCalendarRef = triggerNode.Item.calendarname.TrimEmptyToNull();
string triggerJobName = triggerNode.Item.jobname.TrimEmptyToNull();
string triggerJobGroup = triggerNode.Item.jobgroup.TrimEmptyToNull();
int triggerPriority = TriggerConstants.DefaultPriority;
if (!triggerNode.Item.priority.IsNullOrWhiteSpace())
{
triggerPriority = Convert.ToInt32(triggerNode.Item.priority);
}
DateTimeOffset triggerStartTime = SystemTime.UtcNow();
if (triggerNode.Item.Item != null)
{
if (triggerNode.Item.Item is DateTime time)
{
triggerStartTime = new DateTimeOffset(time);
}
else
{
triggerStartTime = triggerStartTime.AddSeconds(Convert.ToInt32(triggerNode.Item.Item));
}
}
DateTime?triggerEndTime = triggerNode.Item.endtimeSpecified ? triggerNode.Item.endtime : (DateTime?)null;
IScheduleBuilder sched;
if (triggerNode.Item is simpleTriggerType simpleTrigger)
{
string repeatCountString = simpleTrigger.repeatcount.TrimEmptyToNull();
string repeatIntervalString = simpleTrigger.repeatinterval.TrimEmptyToNull();
int repeatCount = ParseSimpleTriggerRepeatCount(repeatCountString);
TimeSpan repeatInterval = repeatIntervalString == null ? TimeSpan.Zero : TimeSpan.FromMilliseconds(Convert.ToInt64(repeatIntervalString));
sched = SimpleScheduleBuilder.Create()
.WithInterval(repeatInterval)
.WithRepeatCount(repeatCount);
if (!simpleTrigger.misfireinstruction.IsNullOrWhiteSpace())
{
((SimpleScheduleBuilder)sched).WithMisfireHandlingInstruction(ReadMisfireInstructionFromString(simpleTrigger.misfireinstruction));
}
}
else if (triggerNode.Item is cronTriggerType)
{
cronTriggerType cronTrigger = (cronTriggerType)triggerNode.Item;
string cronExpression = cronTrigger.cronexpression.TrimEmptyToNull();
string timezoneString = cronTrigger.timezone.TrimEmptyToNull();
TimeZoneInfo tz = timezoneString != null?TimeZoneUtil.FindTimeZoneById(timezoneString) : null;
sched = CronScheduleBuilder.CronSchedule(cronExpression)
.InTimeZone(tz);
if (!cronTrigger.misfireinstruction.IsNullOrWhiteSpace())
{
((CronScheduleBuilder)sched).WithMisfireHandlingInstruction(ReadMisfireInstructionFromString(cronTrigger.misfireinstruction));
}
}
else if (triggerNode.Item is calendarIntervalTriggerType)
{
calendarIntervalTriggerType calendarIntervalTrigger = (calendarIntervalTriggerType)triggerNode.Item;
string repeatIntervalString = calendarIntervalTrigger.repeatinterval.TrimEmptyToNull();
IntervalUnit intervalUnit = ParseDateIntervalTriggerIntervalUnit(calendarIntervalTrigger.repeatintervalunit.TrimEmptyToNull());
int repeatInterval = repeatIntervalString == null ? 0 : Convert.ToInt32(repeatIntervalString);
sched = CalendarIntervalScheduleBuilder.Create()
.WithInterval(repeatInterval, intervalUnit);
if (!calendarIntervalTrigger.misfireinstruction.IsNullOrWhiteSpace())
{
((CalendarIntervalScheduleBuilder)sched).WithMisfireHandlingInstruction(ReadMisfireInstructionFromString(calendarIntervalTrigger.misfireinstruction));
}
}
else
{
throw new SchedulerConfigException("Unknown trigger type in XML configuration");
}
IMutableTrigger trigger = (IMutableTrigger)TriggerBuilder.Create()
.WithIdentity(triggerName, triggerGroup)
.WithDescription(triggerDescription)
.ForJob(triggerJobName, triggerJobGroup)
.StartAt(triggerStartTime)
.EndAt(triggerEndTime)
.WithPriority(triggerPriority)
.ModifiedByCalendar(triggerCalendarRef)
.WithSchedule(sched)
.Build();
if (triggerNode.Item.jobdatamap != null && triggerNode.Item.jobdatamap.entry != null)
{
foreach (entryType entry in triggerNode.Item.jobdatamap.entry)
{
string key = entry.key.TrimEmptyToNull();
string value = entry.value.TrimEmptyToNull();
trigger.JobDataMap.Add(key, value);
}
}
if (Log.IsDebugEnabled())
{
Log.Debug("Parsed trigger definition: " + trigger);
}
AddTriggerToSchedule(trigger);
}
}
public void TestBasicStorageFunctions()
{
var sched = CreateScheduler("TestBasicStorageFunctions", 2);
sched.Start();
// test basic storage functions of scheduler...
IJobDetail job = JobBuilder.Create()
.OfType <TestJob>()
.WithIdentity("j1")
.StoreDurably()
.Build();
Assert.IsFalse(sched.CheckExists(new JobKey("j1")), "Unexpected existence of job named 'j1'.");
sched.AddJob(job, false);
Assert.IsTrue(sched.CheckExists(new JobKey("j1")), "Expected existence of job named 'j1' but checkExists return false.");
job = sched.GetJobDetail(new JobKey("j1"));
Assert.IsNotNull(job, "Stored job not found!");
sched.DeleteJob(new JobKey("j1"));
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("t1")
.ForJob(job)
.StartNow()
.WithSimpleSchedule(x => x.RepeatForever().WithIntervalInSeconds(5))
.Build();
Assert.IsFalse(sched.CheckExists(new TriggerKey("t1")), "Unexpected existence of trigger named '11'.");
sched.ScheduleJob(job, trigger);
Assert.IsTrue(sched.CheckExists(new TriggerKey("t1")), "Expected existence of trigger named 't1' but checkExists return false.");
job = sched.GetJobDetail(new JobKey("j1"));
Assert.IsNotNull(job, "Stored job not found!");
trigger = sched.GetTrigger(new TriggerKey("t1"));
Assert.IsNotNull(trigger, "Stored trigger not found!");
job = JobBuilder.Create()
.OfType <TestJob>()
.WithIdentity("j2", "g1")
.Build();
trigger = TriggerBuilder.Create()
.WithIdentity("t2", "g1")
.ForJob(job)
.StartNow()
.WithSimpleSchedule(x => x.RepeatForever().WithIntervalInSeconds(5))
.Build();
sched.ScheduleJob(job, trigger);
job = JobBuilder.Create()
.OfType <TestJob>()
.WithIdentity("j3", "g1")
.Build();
trigger = TriggerBuilder.Create()
.WithIdentity("t3", "g1")
.ForJob(job)
.StartNow()
.WithSimpleSchedule(x => x.RepeatForever().WithIntervalInSeconds(5))
.Build();
sched.ScheduleJob(job, trigger);
IList <string> jobGroups = sched.GetJobGroupNames();
IList <string> triggerGroups = sched.GetTriggerGroupNames();
Assert.AreEqual(2, jobGroups.Count, "Job group list size expected to be = 2 ");
Assert.AreEqual(2, triggerGroups.Count, "Trigger group list size expected to be = 2 ");
Collection.ISet <JobKey> jobKeys = sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(JobKey.DefaultGroup));
Collection.ISet <TriggerKey> triggerKeys = sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals(TriggerKey.DefaultGroup));
Assert.AreEqual(1, jobKeys.Count, "Number of jobs expected in default group was 1 ");
Assert.AreEqual(1, triggerKeys.Count, "Number of triggers expected in default group was 1 ");
jobKeys = sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("g1"));
triggerKeys = sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("g1"));
Assert.AreEqual(2, jobKeys.Count, "Number of jobs expected in 'g1' group was 2 ");
Assert.AreEqual(2, triggerKeys.Count, "Number of triggers expected in 'g1' group was 2 ");
TriggerState s = sched.GetTriggerState(new TriggerKey("t2", "g1"));
Assert.AreEqual(TriggerState.Normal, s, "State of trigger t2 expected to be NORMAL ");
sched.PauseTrigger(new TriggerKey("t2", "g1"));
s = sched.GetTriggerState(new TriggerKey("t2", "g1"));
Assert.AreEqual(TriggerState.Paused, s, "State of trigger t2 expected to be PAUSED ");
sched.ResumeTrigger(new TriggerKey("t2", "g1"));
s = sched.GetTriggerState(new TriggerKey("t2", "g1"));
Assert.AreEqual(TriggerState.Normal, s, "State of trigger t2 expected to be NORMAL ");
Collection.ISet <string> pausedGroups = sched.GetPausedTriggerGroups();
Assert.AreEqual(0, pausedGroups.Count, "Size of paused trigger groups list expected to be 0 ");
sched.PauseTriggers(GroupMatcher <TriggerKey> .GroupEquals("g1"));
// test that adding a trigger to a paused group causes the new trigger to be paused also...
job = JobBuilder.Create()
.OfType <TestJob>()
.WithIdentity("j4", "g1")
.Build();
trigger = TriggerBuilder.Create()
.WithIdentity("t4", "g1")
.ForJob(job)
.StartNow()
.WithSimpleSchedule(x => x.RepeatForever().WithIntervalInSeconds(5))
.Build();
sched.ScheduleJob(job, trigger);
pausedGroups = sched.GetPausedTriggerGroups();
Assert.AreEqual(1, pausedGroups.Count, "Size of paused trigger groups list expected to be 1 ");
s = sched.GetTriggerState(new TriggerKey("t2", "g1"));
Assert.AreEqual(TriggerState.Paused, s, "State of trigger t2 expected to be PAUSED ");
s = sched.GetTriggerState(new TriggerKey("t4", "g1"));
Assert.AreEqual(TriggerState.Paused, s, "State of trigger t4 expected to be PAUSED");
sched.ResumeTriggers(GroupMatcher <TriggerKey> .GroupEquals("g1"));
s = sched.GetTriggerState(new TriggerKey("t2", "g1"));
Assert.AreEqual(TriggerState.Normal, s, "State of trigger t2 expected to be NORMAL ");
s = sched.GetTriggerState(new TriggerKey("t4", "g1"));
Assert.AreEqual(TriggerState.Normal, s, "State of trigger t2 expected to be NORMAL ");
pausedGroups = sched.GetPausedTriggerGroups();
Assert.AreEqual(0, pausedGroups.Count, "Size of paused trigger groups list expected to be 0 ");
Assert.IsFalse(sched.UnscheduleJob(new TriggerKey("foasldfksajdflk")), "Scheduler should have returned 'false' from attempt to unschedule non-existing trigger. ");
Assert.IsTrue(sched.UnscheduleJob(new TriggerKey("t3", "g1")), "Scheduler should have returned 'true' from attempt to unschedule existing trigger. ");
jobKeys = sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("g1"));
triggerKeys = sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("g1"));
Assert.AreEqual(2, jobKeys.Count, "Number of jobs expected in 'g1' group was 2 "); // job should have been deleted also, because it is non-durable
Assert.AreEqual(2, triggerKeys.Count, "Number of triggers expected in 'g1' group was 2 ");
Assert.IsTrue(sched.UnscheduleJob(new TriggerKey("t1")), "Scheduler should have returned 'true' from attempt to unschedule existing trigger. ");
jobKeys = sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(JobKey.DefaultGroup));
triggerKeys = sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals(TriggerKey.DefaultGroup));
Assert.AreEqual(1, jobKeys.Count, "Number of jobs expected in default group was 1 "); // job should have been left in place, because it is non-durable
Assert.AreEqual(0, triggerKeys.Count, "Number of triggers expected in default group was 0 ");
sched.Shutdown();
}
public bool Post([FromBody] TaskWidget widget)
{
// 判斷 Cron 表达式
if (string.IsNullOrEmpty(widget.CronExpression))
{
return(false);
}
// 系統内置任務禁止更改
// 演示模式下禁止刪除内置任務
if (DictHelper.RetrieveSystemModel() && _tasks.Any(t => t.Equals(widget.Name, StringComparison.OrdinalIgnoreCase)))
{
return(false);
}
// 加載任務執行體
// 此處可以擴展為任意 DLL 中的任意继承 ITask 接口的實體類
var taskExecutor = LgbActivator.CreateInstance <ITask>("Bootstrap.Admin", widget.TaskExecutorName);
if (taskExecutor == null)
{
return(false);
}
// 此處未存储到資料庫中，直接送入任務中心
TaskServicesManager.Remove(widget.Name);
TaskServicesManager.GetOrAdd(widget.Name, token => taskExecutor.Execute(token), TriggerBuilder.Build(widget.CronExpression));
return(true);
}
private bool ExecuteWebApi(SchedulerConfigModel list)
{
try
{
var flag = true;
SchedulerHelper scheduler = new SchedulerHelper();
SchedulerRequest request = new SchedulerRequest();
request.JobName = list.JobName;
request.JobGroup = list.JobGroup;
request.TriggerName = list.JobName + "Trigger";
request.TriggerGroupName = list.JobGroup + "Trigger";
request.CronTab = list.CronTab;
request.StartTime = list.StartTime;
if (list.EndTime != null)
{
request.EndTime = list.EndTime;
}
else
{
request.EndTime = null;
}
request.RequestType = list.RequestType;
request.RequestUrl = list.RequestUrl;
var json = JsonConvert.SerializeObject(request);
DateTimeOffset?end = null;
if (request.EndTime != null)
{
end = DateTime.SpecifyKind(Convert.ToDateTime(request.EndTime), DateTimeKind.Local);
if (request.EndTime < DateTime.Now)
{
flag = false;
}
}
if (flag)
{
IJobDetail jobDetail = JobBuilder.Create <FileJob>()
.WithIdentity(request.JobName, request.JobGroup)
.UsingJobData("jobJson", json)
.Build();
CronTriggerImpl tigger = (CronTriggerImpl)TriggerBuilder.Create()
.WithIdentity(request.TriggerName, request.TriggerGroupName)
.WithCronSchedule(request.CronTab)
.ForJob(request.JobName, request.JobGroup)
.StartNow()
.EndAt(end)
.Build();
DateTimeOffset dt = scheduler.scheduleJob(jobDetail, tigger);
}
else
{
}
return(true);
}
catch (Exception ex)
{
//插入日志
SchedulerRequest request = new SchedulerRequest();
request.JobGroup = list.JobGroup;
request.JobName = list.JobName;
request.RequestType = list.RequestType;
request.RequestUrl = list.RequestUrl;
request.ReturnMsg = "Job-Exception: " + (ex.ToString().Length > 450 ? ex.ToString().Substring(0, 450) : ex.ToString());
request.LogStatus = (int)JobEnum.LogStatus.ExceptInfo;
SchedulerConfigDB.InsertLog(request);
//数据状态更新为0,防止重复执行
SchedulerConfigDB.UpdateStatus(list.ID);
return(false);
}
}
static async Task Main(string[] args)
{
try
{
Console.WriteLine("------- Initializing -------------------");
NameValueCollection properties = new NameValueCollection
{
["quartz.scheduler.instanceName"] = "RemoteClient",
["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz",
["quartz.threadPool.threadCount"] = "5",
["quartz.scheduler.proxy"] = "true",
["quartz.scheduler.proxy.address"] = "tcp://127.0.0.1:555/QuartzScheduler"
};
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory(properties);
IScheduler sched = await sf.GetScheduler();
// First we must get a reference to a scheduler
//ISchedulerFactory sf = new StdSchedulerFactory();
//IScheduler sched = await sf.GetScheduler();
Console.WriteLine("------- Initialization Complete --------");
sched.Start();
// define the job and tie it to our HelloJob class
IJobDetail oojob = JobBuilder.Create <OOTestJob>()
.WithIdentity("oojob1", "oogroup1")
.Build();
oojob.JobDataMap.Put("OOTestJob1", "Bla Bla");
oojob.JobDataMap.Put("User", "Gary Bell");
// Trigger the job to run on the next round minute
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("ootrigger1", "oogroup1")
.StartAt(DateBuilder.FutureDate(5, IntervalUnit.Second))
.Build();
// Tell quartz to schedule the job using our trigger
await sched.ScheduleJob(oojob, trigger);
var keys = await sched.GetJobKeys(GroupMatcher <JobKey> .AnyGroup());
foreach (var key in keys)
{
Console.WriteLine("\t " + key);
var sw = new Stopwatch();
sw.Start();
while (sw.ElapsedMilliseconds < 60000)
{
var jobs = await sched.GetCurrentlyExecutingJobs();
if (jobs.Count > 0)
{
Console.WriteLine($"---Waiting on {jobs.Count} to finish.");
foreach (var job in jobs)
{
Console.WriteLine($"\tJob Desc: {job.JobDetail.Description}");
foreach (var jobdataStr in job.MergedJobDataMap.Keys)
{
Console.WriteLine($"\t{jobdataStr} = {job.MergedJobDataMap[jobdataStr]}");
}
}
}
else
{
var groups = await sched.GetJobGroupNames();
if (groups.Count > 0)
{
Console.WriteLine($"There are {groups.Count} scheduled");
}
else
{
Console.WriteLine($"***Press a key to exit");
break;
}
}
await Task.Delay(1500);
}
}
Console.Read();
return;
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
private async Task TestMatchers(IScheduler scheduler)
{
await scheduler.Clear();
var job = JobBuilder.Create <NoOpJob>().WithIdentity("job1", "aaabbbccc").StoreDurably().Build();
await scheduler.AddJob(job, true);
var schedule = SimpleScheduleBuilder.Create();
var trigger =
TriggerBuilder.Create().WithIdentity("trig1", "aaabbbccc").WithSchedule(schedule).ForJob(job).Build();
await scheduler.ScheduleJob(trigger);
job = JobBuilder.Create <NoOpJob>().WithIdentity("job1", "xxxyyyzzz").StoreDurably().Build();
await scheduler.AddJob(job, true);
schedule = SimpleScheduleBuilder.Create();
trigger =
TriggerBuilder.Create().WithIdentity("trig1", "xxxyyyzzz").WithSchedule(schedule).ForJob(job).Build();
await scheduler.ScheduleJob(trigger);
job = JobBuilder.Create <NoOpJob>().WithIdentity("job2", "xxxyyyzzz").StoreDurably().Build();
await scheduler.AddJob(job, true);
schedule = SimpleScheduleBuilder.Create();
trigger =
TriggerBuilder.Create().WithIdentity("trig2", "xxxyyyzzz").WithSchedule(schedule).ForJob(job).Build();
await scheduler.ScheduleJob(trigger);
var jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup());
jkeys.Count.Should().Be(3, "Wrong number of jobs found by anything matcher");
jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("xxxyyyzzz"));
jkeys.Count.Should().Be(2, "Wrong number of jobs found by equals matcher");
jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("aaabbbccc"));
jkeys.Count.Should().Be(1, "Wrong number of jobs found by equals matcher");
jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("aa"));
jkeys.Count.Should().Be(1, "Wrong number of jobs found by starts with matcher");
jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("xx"));
jkeys.Count.Should().Be(2, "Wrong number of jobs found by starts with matcher");
jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEndsWith("cc"));
jkeys.Count.Should().Be(1, "Wrong number of jobs found by ends with matcher");
jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEndsWith("zzz"));
jkeys.Count.Should().Be(2, "Wrong number of jobs found by ends with matcher");
jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupContains("bc"));
jkeys.Count.Should().Be(1, "Wrong number of jobs found by contains with matcher");
jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupContains("yz"));
jkeys.Count.Should().Be(2, "Wrong number of jobs found by contains with matcher");
var tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .AnyGroup());
tkeys.Count.Should().Be(3, "Wrong number of triggers found by anything matcher");
tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("xxxyyyzzz"));
tkeys.Count.Should().Be(2, "Wrong number of triggers found by equals matcher");
tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("aaabbbccc"));
tkeys.Count.Should().Be(1, "Wrong number of triggers found by equals matcher");
tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("aa"));
tkeys.Count.Should().Be(1, "Wrong number of triggers found by starts with matcher");
tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("xx"));
tkeys.Count.Should().Be(2, "Wrong number of triggers found by starts with matcher");
tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEndsWith("cc"));
tkeys.Count.Should().Be(1, "Wrong number of triggers found by ends with matcher");
tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEndsWith("zzz"));
tkeys.Count.Should().Be(2, "Wrong number of triggers found by ends with matcher");
tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupContains("bc"));
tkeys.Count.Should().Be(1, "Wrong number of triggers found by contains with matcher");
tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupContains("yz"));
tkeys.Count.Should().Be(2, "Wrong number of triggers found by contains with matcher");
}
private static ITrigger CreateTrigger(string key)
{
const int localTimeZone = -4;
switch (key.ToUpper())
{
case "A CADA 1 SEGUNDO":
return(TriggerBuilder.Create()
.WithDescription("A cada 1 Segundo")
.WithSimpleSchedule(x => x
.WithIntervalInSeconds(1)
.RepeatForever()
.WithMisfireHandlingInstructionNowWithExistingCount())
.Build());
case "A CADA 5 SEGUNDOS":
return(TriggerBuilder.Create()
.WithDescription("A cada 5 Segundos")
.WithSimpleSchedule(x => x
.WithIntervalInSeconds(5)
.RepeatForever()
.WithMisfireHandlingInstructionNowWithExistingCount())
.Build());
case "A CADA 10 SEGUNDOS":
return(TriggerBuilder.Create()
.WithDescription("A cada 10 Segundos")
.WithSimpleSchedule(x => x
.WithIntervalInSeconds(10)
.RepeatForever()
.WithMisfireHandlingInstructionNowWithExistingCount())
.Build());
case "A CADA 15 SEGUNDOS":
return(TriggerBuilder.Create()
.WithDescription("A cada 15 Segundos")
.WithSimpleSchedule(x => x
.WithIntervalInSeconds(15)
.RepeatForever()
.WithMisfireHandlingInstructionNowWithExistingCount())
.Build());
case "A CADA 60 SEGUNDOS":
return(TriggerBuilder.Create()
.WithDescription("A cada 60 Segundos")
.WithSimpleSchedule(x => x
.WithIntervalInSeconds(60)
.RepeatForever()
.WithMisfireHandlingInstructionNowWithExistingCount())
.Build());
case "A CADA 10 MINUTOS":
return(TriggerBuilder.Create()
.WithDescription("A cada 10 Minutos")
.WithSimpleSchedule(x => x
.WithIntervalInMinutes(10)
.RepeatForever()
.WithMisfireHandlingInstructionNowWithExistingCount())
.Build());
case "A CADA 1 HORA":
return(TriggerBuilder.Create()
.WithDescription("A cada 1 Hora")
.WithSimpleSchedule(x => x
.WithIntervalInHours(1)
.RepeatForever()
.WithMisfireHandlingInstructionNowWithExistingCount())
.Build());
case "TODO DIA AS 5AM (UTC-4)":
return(TriggerBuilder.Create()
.WithDescription("Todo dia as 5AM (UTC-4)")
.WithDailyTimeIntervalSchedule(x => x.
WithIntervalInHours(24)
.OnEveryDay()
.StartingDailyAt(TimeOfDay.HourAndMinuteOfDay(5 - localTimeZone, 0))
.InTimeZone(TimeZoneInfo.Utc))
.Build());
case "TODO DIA AS 6AM (UTC-4)":
return(TriggerBuilder.Create()
.WithDescription("Todo dia as 6AM (UTC-4)")
.WithDailyTimeIntervalSchedule(x => x.
WithIntervalInHours(24)
.OnEveryDay()
.StartingDailyAt(TimeOfDay.HourAndMinuteOfDay(6 - localTimeZone, 0))
.InTimeZone(TimeZoneInfo.Utc))
.Build());
case "A CADA 6H COMEÇANDO AS 5":
return(TriggerBuilder.Create()
.WithDescription("Todo dia as 6AM (UTC-4)")
.WithDailyTimeIntervalSchedule(x => x.
WithIntervalInHours(24)
.OnEveryDay()
.StartingDailyAt(TimeOfDay.HourAndMinuteOfDay(5 - localTimeZone, 0))
.InTimeZone(TimeZoneInfo.Utc))
.Build());
default:
throw new Exception("Trigger not implemented:\"" + key + "\"");
}
}
/// <summary>
/// 添加简单重复执行任务
/// </summary>
/// <param name="jobName">任务名称</param>
/// <param name="starTime">开始时间</param>
/// <param name="endTime">结束时间</param>
/// <param name="keyValue">任务主键</param>
/// <param name="value">间隔值</param>
/// <param name="type">间隔类型</param>
public static void AddRepeatJob(string jobName, string starTime, string endTime, string keyValue, int value, string type)
{
try
{
IScheduler sched = schedFact.GetScheduler(); //得到一个调度程序
IJobDetail job = JobBuilder.Create <SchedulingHelper>() //新建任务执行类
.WithIdentity(jobName, "lrts") // name "myJob", group "group1"
.UsingJobData("keyValue", keyValue) //传递参数
.Build();
///开始时间处理
DateTime StarTime = DateTime.Now;
if (!string.IsNullOrEmpty(starTime))
{
StarTime = Convert.ToDateTime(starTime);
}
DateTimeOffset starRunTime = DateBuilder.NextGivenSecondDate(StarTime, 1);
///结束时间处理
DateTime EndTime = DateTime.MaxValue.AddDays(-1);
if (!string.IsNullOrEmpty(endTime))
{
EndTime = Convert.ToDateTime(endTime);
}
DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(EndTime, 1);
ITrigger trigger = null;
switch (type)
{
case "minute": // 分钟
trigger = TriggerBuilder.Create().WithIdentity(jobName, "lrts")
.StartAt(starRunTime)
.EndAt(endRunTime)
.WithSimpleSchedule(t =>
t.WithIntervalInMinutes(value)
.RepeatForever())
.Build();
break;
case "hours": // 小时
trigger = TriggerBuilder.Create()
.WithIdentity(jobName, "lrts")
.StartAt(starRunTime)
.EndAt(endRunTime)
.WithSimpleSchedule(t =>
t.WithIntervalInHours(value)
.RepeatForever())
.Build();
break;
case "day": // 天
trigger = TriggerBuilder.Create()
.WithIdentity(jobName, "lrts")
.StartAt(starRunTime)
.EndAt(endRunTime)
.WithSchedule(
CalendarIntervalScheduleBuilder.Create()
.WithIntervalInDays(value)
)
.Build();
break;
case "week": // 周
trigger = TriggerBuilder.Create()
.WithIdentity(jobName, "lrts")
.StartAt(starRunTime)
.EndAt(endRunTime)
.WithSchedule(
CalendarIntervalScheduleBuilder.Create()
.WithIntervalInWeeks(value)
)
.Build();
break;
}
//实例化
sched.ScheduleJob(job, trigger);
//启动
if (!sched.IsStarted)
{
sched.Start();
}
}
catch (Exception e)
{
throw (e);
}
}
public async Task Run(ILog log)
{
log.Info("------- Initializing -------------------");
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = sf.GetScheduler();
log.Info("------- Initialization Complete -----------");
log.Info("------- Scheduling Jobs -----------");
// jobs can be scheduled before start() has been called
// get a "nice round" time a few seconds in the future...
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 15);
// statefulJob1 will run every three seconds
// (but it will delay for ten seconds)
IJobDetail job = JobBuilder.Create <StatefulDumbJob>()
.WithIdentity("statefulJob1", "group1")
.UsingJobData(StatefulDumbJob.ExecutionDelay, 10000L)
.Build();
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger1", "group1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(3).RepeatForever())
.Build();
DateTimeOffset ft = sched.ScheduleJob(job, trigger);
log.Info($"{job.Key} will run at: {ft.ToString("r")} and repeat: {trigger.RepeatCount} times, every {trigger.RepeatInterval.TotalSeconds} seconds");
// statefulJob2 will run every three seconds
// (but it will delay for ten seconds - and therefore purposely misfire after a few iterations)
job = JobBuilder.Create <StatefulDumbJob>()
.WithIdentity("statefulJob2", "group1")
.UsingJobData(StatefulDumbJob.ExecutionDelay, 10000L)
.Build();
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger2", "group1")
.StartAt(startTime)
.WithSimpleSchedule(x => x
.WithIntervalInSeconds(3)
.RepeatForever()
.WithMisfireHandlingInstructionIgnoreMisfires()) // set misfire instructions
.Build();
ft = sched.ScheduleJob(job, trigger);
log.Info($"{job.Key} will run at: {ft.ToString("r")} and repeat: {trigger.RepeatCount} times, every {trigger.RepeatInterval.TotalSeconds} seconds");
// MisfireJob will run every three seconds
// (but it will delay for ten seconds - and therefore purposely misfire after a few iterations)
job = JobBuilder.Create <MisfireJob>()
.WithIdentity("MisfireJob", "group1")
.UsingJobData(MisfireJob.ExecutionDelay, 30L)
.Build();
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger3", "group1")
.StartAt(startTime)
.WithSimpleSchedule(x => x
.WithIntervalInSeconds(3)
.RepeatForever()
.WithMisfireHandlingInstructionNowWithExistingCount()) // set misfire instructions
.Build();
ft = sched.ScheduleJob(job, trigger);
log.Info($"{job.Key} will run at: {ft.ToString("r")} and repeat: {trigger.RepeatCount} times, every {trigger.RepeatInterval.TotalSeconds} seconds");
log.Info("------- Starting Scheduler ----------------");
// jobs don't start firing until start() has been called...
sched.Start();
log.Info("------- Started Scheduler -----------------");
// sleep for ten minutes for triggers to file....
await Task.Delay(TimeSpan.FromMinutes(10));
log.Info("------- Shutting Down ---------------------");
sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = sched.GetMetaData();
log.Info($"Executed {metaData.NumberOfJobsExecuted} jobs.");
}
public static void Start()
{
#region Scheduler Envia Email Sms
IScheduler scheduler = StdSchedulerFactory.GetDefaultScheduler();
scheduler.Start();
IJobDetail jobEmailSms = JobBuilder.Create <EnvioEmailSms>().Build();
ITrigger triggerEmailSms = TriggerBuilder.Create()
.WithIdentity("trigger1", "group1")
.StartNow()
.WithSimpleSchedule(x => x
.WithIntervalInSeconds(120) // Chama serviço para enviar Email e Sms de 2 em 2 minutos.
.RepeatForever())
.Build();
scheduler.ScheduleJob(jobEmailSms, triggerEmailSms);
#endregion
#region Scheduler Gera Cotação
IScheduler schedulerGeraCotacao = StdSchedulerFactory.GetDefaultScheduler();
schedulerGeraCotacao.Start();
IJobDetail jobGeraCotacao = JobBuilder.Create <GeraCotacao>().Build();
ITrigger triggerGeraCotacao = TriggerBuilder.Create()
.WithIdentity("trigger2", "group2")
.StartNow()
.WithCronSchedule("0 00 12 * * ?") // Ás 12:00:00 é gerado cotação caso exista pedidos
.Build();
schedulerGeraCotacao.ScheduleJob(jobGeraCotacao, triggerGeraCotacao);
#endregion
#region Scheduler Fechar Cotação
IScheduler schedulerFecharCotacao = StdSchedulerFactory.GetDefaultScheduler();
schedulerFecharCotacao.Start();
IJobDetail jobFecharCotacao = JobBuilder.Create <FecharCotacao>().Build();
ITrigger triggerFecharCotacao = TriggerBuilder.Create()
.WithIdentity("trigger3", "group3")
.StartNow()
.WithSimpleSchedule(x => x
.WithIntervalInSeconds(2) // Chama serviço para fechar cotação de 2 em 2 minutos.
.RepeatForever())
.Build();
schedulerFecharCotacao.ScheduleJob(jobFecharCotacao, triggerFecharCotacao);
#endregion
#region Scheduler Notificacoes e Alertas
IScheduler schedulerNotificacoesAlertas = StdSchedulerFactory.GetDefaultScheduler();
schedulerNotificacoesAlertas.Start();
IJobDetail jobNotificacoesAlertas = JobBuilder.Create <NotificacoesAlertas>().Build();
ITrigger triggerNotificacoesAlertas = TriggerBuilder.Create()
.WithIdentity("trigger4", "group4")
.StartNow()
.WithSimpleSchedule(x => x
.WithIntervalInSeconds(2) // Chama serviço para enviar notificações e alertas de 2 em 2 minutos.
.RepeatForever())
.Build();
schedulerNotificacoesAlertas.ScheduleJob(jobNotificacoesAlertas, triggerNotificacoesAlertas);
#endregion
#region Scheduler Pagamentos / Gera Fatura Fornecedores
IScheduler schedulerPagamentosFatura = StdSchedulerFactory.GetDefaultScheduler();
schedulerPagamentosFatura.Start();
IJobDetail jobPagamentosFatura = JobBuilder.Create <GeraFatura>().Build();
ITrigger triggerPagamentosFatura = TriggerBuilder.Create()
.WithIdentity("trigger5", "group5")
.StartNow()
.WithCronSchedule("0 00 01 * * ?") // Ás 00:01:00 são gerados boletos
.Build();
schedulerPagamentosFatura.ScheduleJob(jobPagamentosFatura, triggerPagamentosFatura);
#endregion
#region Scheduler Pagamentos / Gera Mensalidade Membros
IScheduler schedulerPagamentosMensalidade = StdSchedulerFactory.GetDefaultScheduler();
schedulerPagamentosMensalidade.Start();
IJobDetail jobPagamentosMensalidade = JobBuilder.Create <GeraMensalidade>().Build();
ITrigger triggerPagamentosMensalidade = TriggerBuilder.Create()
.WithIdentity("trigger6", "group6")
.StartNow()
.WithCronSchedule("0 00 01 * * ?") // Ás 00:01:00 são geradas mensalidades
.Build();
schedulerPagamentosMensalidade.ScheduleJob(jobPagamentosMensalidade, triggerPagamentosMensalidade);
#endregion
}
public virtual void Run()
{
ILog log = LogManager.GetLogger(typeof(CronTriggerExample));
log.Info("------- Initializing -------------------");
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = sf.GetScheduler();
log.Info("------- Initialization Complete --------");
log.Info("------- Scheduling Jobs ----------------");
// jobs can be scheduled before sched.start() has been called
// job 1 will run every 20 seconds
IJobDetail job = JobBuilder.NewJob <SimpleJob>()
.WithIdentity("job1", "group1")
.Build();
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
.WithIdentity("trigger1", "group1")
.WithSchedule(CronScheduleBuilder.CronSchedule("0/20 * * * * ?"))
.Build();
DateTimeOffset ft = sched.ScheduleJob(job, trigger);
log.Info(job.Key + " has been scheduled to run at: " + ft
+ " and repeat based on expression: "
+ trigger.CronExpressionString);
// job 2 will run every other minute (at 15 seconds past the minute)
job = JobBuilder.NewJob <SimpleJob>()
.WithIdentity("job2", "group1")
.Build();
trigger = (ICronTrigger)TriggerBuilder.Create()
.WithIdentity("trigger2", "group1")
.WithSchedule(CronScheduleBuilder.CronSchedule("15 0/2 * * * ?"))
.Build();
ft = sched.ScheduleJob(job, trigger);
log.Info(job.Key + " has been scheduled to run at: " + ft
+ " and repeat based on expression: "
+ trigger.CronExpressionString);
// job 3 will run every other minute but only between 8am and 5pm
job = JobBuilder.NewJob <SimpleJob>()
.WithIdentity("job3", "group1")
.Build();
trigger = (ICronTrigger)TriggerBuilder.Create()
.WithIdentity("trigger3", "group1")
.WithSchedule(CronScheduleBuilder.CronSchedule("0 0/2 8-17 * * ?"))
.Build();
ft = sched.ScheduleJob(job, trigger);
log.Info(job.Key + " has been scheduled to run at: " + ft
+ " and repeat based on expression: "
+ trigger.CronExpressionString);
// job 4 will run every three minutes but only between 5pm and 11pm
job = JobBuilder.NewJob <SimpleJob>()
.WithIdentity("job4", "group1")
.Build();
trigger = (ICronTrigger)TriggerBuilder.Create()
.WithIdentity("trigger4", "group1")
.WithSchedule(CronScheduleBuilder.CronSchedule("0 0/3 17-23 * * ?"))
.Build();
ft = sched.ScheduleJob(job, trigger);
log.Info(job.Key + " has been scheduled to run at: " + ft
+ " and repeat based on expression: "
+ trigger.CronExpressionString);
// job 5 will run at 10am on the 1st and 15th days of the month
job = JobBuilder.NewJob <SimpleJob>()
.WithIdentity("job5", "group1")
.Build();
trigger = (ICronTrigger)TriggerBuilder.Create()
.WithIdentity("trigger5", "group1")
.WithSchedule(CronScheduleBuilder.CronSchedule("0 0 10am 1,15 * ?"))
.Build();
ft = sched.ScheduleJob(job, trigger);
log.Info(job.Key + " has been scheduled to run at: " + ft
+ " and repeat based on expression: "
+ trigger.CronExpressionString);
// job 6 will run every 30 seconds but only on Weekdays (Monday through Friday)
job = JobBuilder.NewJob <SimpleJob>()
.WithIdentity("job6", "group1")
.Build();
trigger = (ICronTrigger)TriggerBuilder.Create()
.WithIdentity("trigger6", "group1")
.WithSchedule(CronScheduleBuilder.CronSchedule("0,30 * * ? * MON-FRI"))
.Build();
ft = sched.ScheduleJob(job, trigger);
log.Info(job.Key + " has been scheduled to run at: " + ft
+ " and repeat based on expression: "
+ trigger.CronExpressionString);
// job 7 will run every 30 seconds but only on Weekends (Saturday and Sunday)
job = JobBuilder.NewJob <SimpleJob>()
.WithIdentity("job7", "group1")
.Build();
trigger = (ICronTrigger)TriggerBuilder.Create()
.WithIdentity("trigger7", "group1")
.WithSchedule(CronScheduleBuilder.CronSchedule("0,30 * * ? * SAT,SUN"))
.Build();
ft = sched.ScheduleJob(job, trigger);
log.Info(job.Key + " has been scheduled to run at: " + ft
+ " and repeat based on expression: "
+ trigger.CronExpressionString);
log.Info("------- Starting Scheduler ----------------");
// All of the jobs have been added to the scheduler, but none of the
// jobs
// will run until the scheduler has been started
sched.Start();
log.Info("------- Started Scheduler -----------------");
log.Info("------- Waiting five minutes... ------------");
try
{
// wait five minutes to show jobs
Thread.Sleep(300 * 1000);
// executing...
}
catch (ThreadInterruptedException)
{
}
log.Info("------- Shutting Down ---------------------");
sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = sched.GetMetaData();
log.Info(string.Format("Executed {0} jobs.", metaData.NumberOfJobsExecuted));
}
/// <summary>
/// Adds a trigger that executes at logon of a specific user.
/// </summary>
/// <param name="userId">The user id.</param>
/// <returns><see cref="TriggerBuilder" /> instance.</returns>
public TriggerBuilder AtLogonOf(string userId)
{
var b = new TriggerBuilder(tb, TaskTriggerType.Logon);
((LogonTrigger)b.trigger).UserId = userId;
return b;
}
private static ITrigger BuildCronConfiguredTrigger(string jobUid, string subscriptionName, JobSchedule schedule) => TriggerBuilder.Create() .WithIdentity(jobUid, subscriptionName) .WithCronSchedule(schedule.CronOverride) .Build();
internal MonthlyDOWTriggerBuilder(BuilderInfo taskBuilder, DaysOfTheWeek dow)
: base(taskBuilder)
{
this.trb = new TriggerBuilder(taskBuilder, dow);
}
/// <summary>
/// Register User Internal
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
internal async Task <RegisterUserResult> RegisterInternal(RegisterGeneralModel model)
{
var userResult = new RegisterUserResult();
using (IUnitOfWork unitOfWork = UnitOfWork.Create())
{
var checkUserEmail = unitOfWork.UserRepository.GetAll().FirstOrDefault(a => a.Email == model.Email || a.UserName == model.Email);
if (checkUserEmail != null)
{
userResult.AddError(HttpStatusCode.BadRequest, 10, "This email is already taken ***");
return(userResult);
}
unitOfWork.BeginTransaction();
//Create user record
var user = new ApplicationUser
{
Id = Guid.NewGuid().ToString(),
FirstName = model.FirstName ?? string.Empty,
LastName = model.LastName ?? string.Empty,
UserName = model.Email,
Email = model.Email,
//AvatarFileId = model.AvatarFileId,
HasTempPassword = true,
CreatedById = DbConstants.AdminUserId,
CreatedDate = DateTime.Now
};
if (!string.IsNullOrEmpty(model.UserName))
{
var names = model.UserName.Split(' ');
user.FirstName = names[0];
user.LastName = names.Length > 1 ? names[1] : "";
}
if (!string.IsNullOrEmpty(model.Password))
{
user.PasswordHash = new PasswordHasher().HashPassword(model.Password);
}
user.AutopilotTrack = true;
user.SecurityStamp = Guid.NewGuid().ToString();
#region Need To redo
{
ISchedulerFactory factory = new StdSchedulerFactory();
IScheduler scheduler = factory.GetScheduler();
JobDataMap dataMap = new JobDataMap();
dataMap["registermodel"] = model;
dataMap["userId"] = user.Id;
dataMap["OperationType"] = "Registration";
var job = JobBuilder.Create <UpdateContactJob>()
.WithIdentity("UpdateContactJob").UsingJobData(dataMap)
.Build();
var jobKey = new JobKey("UpdateContactJob");
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("trigger1")
.StartAt(DateTime.Now)
.ForJob(jobKey)
.Build();
if (!scheduler.CheckExists(jobKey))
{
scheduler.ScheduleJob(job, trigger);
}
scheduler.Start();
}
#endregion
unitOfWork.UserRepository.Insert(user);
await unitOfWork.SaveAsync();
ApplicationUserRole userRole = new ApplicationUserRole();
userRole.RoleId = DataLayer.DbConstants.CustomerUserRole;
userRole.UserId = user.Id;
unitOfWork.UserRoleRepository.Insert(userRole);
await unitOfWork.SaveAsync();
Address address = new Address();
address.CreatedById = user.Id;
address.CreatedDate = DateTime.Now;
unitOfWork.AddressRepository.Insert(address);
await unitOfWork.SaveAsync();
CustomerDetails customer = new CustomerDetails();
customer.Id = Guid.NewGuid();
customer.CreatedById = user.Id;
customer.CreatedDate = DateTime.Now;
customer.UserId = user.Id;
customer.ContactPhone = model.ContactPhone;
customer.AddressId = address.Id;
customer.ModifiedReason = "created";
unitOfWork.CustomerDetailsRepository.Insert(customer);
await unitOfWork.SaveAsync();
if (!string.IsNullOrEmpty(model.Provider) && !string.IsNullOrEmpty(model.ExternalAccessToken))
{
var loginInfo = await this.SignInManager.AuthenticationManager.GetExternalLoginInfoAsync();
ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(loginInfo.ExternalIdentity as ClaimsIdentity);
ApplicationUserLogin userLogin = new ApplicationUserLogin();
userLogin.UserId = user.Id;
userLogin.ProviderKey = loginInfo.Login.ProviderKey;
userLogin.LoginProvider = loginInfo.Login.LoginProvider;
unitOfWork.UserLoginRepository.Insert(userLogin);
await unitOfWork.SaveAsync();
}
unitOfWork.CommitTransaction();
if (model.Provider == null)
{
//Senf verification Email
{
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = string.Format("{0}/#/confirm-email?userId={1}&code={2}", Url.Link("Default", new { controller = "account" }), user.Id, Uri.EscapeDataString(code));
await EmailNitificationHelper.Create().SendConfirmationEmail(user, UserManager, callbackUrl);
}
}
userResult.UserId = user.Id;
return(userResult);
}
}
