Refactor life cycle builder internals

ethanhann · ethanhann · commit 0e19378f392e · 2017-12-16T11:59:21.000-05:00
diff --git a/src/InEngine.Core/Queuing/Enqueue.cs b/src/InEngine.Core/Queuing/Enqueue.cs
@@ -9,24 +9,24 @@ namespace InEngine.Core.Queuing
 {
     public static class Enqueue
     {
-        public static IQueueLifeCycleActions Command(Expression<Action> expressionAction)
+        public static IQueueLifeCycleBuilder Command(Expression<Action> expressionAction)
         {
-            return new QueueLifeCycleActions(new Lambda(expressionAction.ToExpressionNode()));
+            return new QueueLifeCycleBuilder(new Lambda(expressionAction.ToExpressionNode()));
         }
 
-        public static IQueueLifeCycleActions Command(AbstractCommand command)
+        public static IQueueLifeCycleBuilder Command(AbstractCommand command)
         {
-            return new QueueLifeCycleActions(command);
+            return new QueueLifeCycleBuilder(command);
         }
 
-        public static IQueueLifeCycleActions Command<T>(T command) where T : AbstractCommand
+        public static IQueueLifeCycleBuilder Command<T>(T command) where T : AbstractCommand
         {
-            return new QueueLifeCycleActions(command);
+            return new QueueLifeCycleBuilder(command);
         }
 
-        public static IQueueLifeCycleActions Commands(IList<AbstractCommand> commands)
+        public static IQueueLifeCycleBuilder Commands(IList<AbstractCommand> commands)
         {
-            return new QueueLifeCycleActions(new Chain() { Commands = commands });
+            return new QueueLifeCycleBuilder(new Chain() { Commands = commands });
         }
     }
 }
diff --git a/src/InEngine.Core/Queuing/LifeCycle/IQueueLifeCycleActions.cs b/src/InEngine.Core/Queuing/LifeCycle/IQueueLifeCycleActions.cs
diff --git a/src/InEngine.Core/Queuing/LifeCycle/IQueueLifeCycleBuilder.cs b/src/InEngine.Core/Queuing/LifeCycle/IQueueLifeCycleBuilder.cs
@@ -0,0 +1,15 @@
+﻿using System;
+
+namespace InEngine.Core.Queuing.LifeCycle
+{
+    public interface IQueueLifeCycleBuilder : IDispatch
+    {
+        AbstractCommand Command { get; set; }
+        IQueueLifeCycleBuilder PingBefore(string url);
+        IQueueLifeCycleBuilder PingAfter(string url);
+        IQueueLifeCycleBuilder WriteOutputTo(string output);
+        IQueueLifeCycleBuilder AppendOutputTo(string output);
+        IQueueLifeCycleBuilder EmailOutputTo(string emailAddress);
+        IQueueLifeCycleBuilder WithRetries(int maximumRetries);
+    }
+}
diff --git a/src/InEngine.Core/Queuing/LifeCycle/QueueLifeCycleBuilder.cs b/src/InEngine.Core/Queuing/LifeCycle/QueueLifeCycleBuilder.cs
@@ -2,79 +2,79 @@
 
 namespace InEngine.Core.Queuing.LifeCycle
 {
-    public class QueueLifeCycleActions : IQueueLifeCycleActions
+    public class QueueLifeCycleBuilder : IQueueLifeCycleBuilder
     {
         public AbstractCommand Command { get; set; }
         public QueueAdapter QueueAdapter { get; set; }
 
-        public QueueLifeCycleActions()
+        public QueueLifeCycleBuilder()
         {}
 
-        public QueueLifeCycleActions(AbstractCommand command) : this()
+        public QueueLifeCycleBuilder(AbstractCommand command) : this()
         {
             Command = command;
         }
 
-        public IQueueLifeCycleActions Before(Action<AbstractCommand> action)
+        public IQueueLifeCycleBuilder Before(Action<AbstractCommand> action)
         {
             Command.CommandLifeCycle.BeforeAction = action;
             return this;
         }
 
-        public IQueueLifeCycleActions After(Action<AbstractCommand> action)
+        public IQueueLifeCycleBuilder After(Action<AbstractCommand> action)
         {
             Command.CommandLifeCycle.AfterAction = action;
             return this;
         }
 
-        public IQueueLifeCycleActions PingBefore(string url)
+        public IQueueLifeCycleBuilder PingBefore(string url)
         {
             Command.CommandLifeCycle.ShouldPingBefore = true;
             Command.CommandLifeCycle.PingBeforeUrl = url;
             return this;
         }
 
-        public IQueueLifeCycleActions PingAfter(string url)
+        public IQueueLifeCycleBuilder PingAfter(string url)
         {
             Command.CommandLifeCycle.ShouldPingAfter = true;
             Command.CommandLifeCycle.PingAfterUrl = url;
             return this;
         }
 
-        public IQueueLifeCycleActions WriteOutputTo(string output)
+        public IQueueLifeCycleBuilder WriteOutputTo(string output)
         {
             Command.CommandLifeCycle.ShouldWriteOutputToFile = true;
             Command.CommandLifeCycle.WriteOutputToFilePath = output;
             return this;
         }
 
-        public IQueueLifeCycleActions AppendOutputTo(string output)
+        public IQueueLifeCycleBuilder AppendOutputTo(string output)
         {
             Command.CommandLifeCycle.ShouldAppendOutputToFile = true;
             Command.CommandLifeCycle.AppendOutputToFilePath = output;
             return this;
         }
 
-        public IQueueLifeCycleActions EmailOutputTo(string emailAddress)
+        public IQueueLifeCycleBuilder EmailOutputTo(string emailAddress)
         {
             Command.CommandLifeCycle.ShouldEmailOutput = true;
             Command.CommandLifeCycle.EmailOutputToAddress = emailAddress;
             return this;
         }
 
-        public IQueueLifeCycleActions ToPrimaryQueue()
+        public IQueueLifeCycleBuilder ToPrimaryQueue()
         {
             QueueAdapter = QueueAdapter.Make(false);
             return this;
         }
 
-        public IQueueLifeCycleActions ToSecondaryQueue()
+        public IQueueLifeCycleBuilder ToSecondaryQueue()
         {
             QueueAdapter = QueueAdapter.Make(true);
             return this;
         }
 
-        public IQueueLifeCycleActions WithRetries(int maximumRetries)
+        public IQueueLifeCycleBuilder WithRetries(int maximumRetries)
         {
             Command.CommandLifeCycle.MaximumRetries = maximumRetries;
             return this;
diff --git a/src/InEngine.Core/Scheduling/LifeCycle/IScheduleLifeCycleActions.cs b/src/InEngine.Core/Scheduling/LifeCycle/IScheduleLifeCycleActions.cs
diff --git a/src/InEngine.Core/Scheduling/LifeCycle/IScheduleLifeCycleBuilder.cs b/src/InEngine.Core/Scheduling/LifeCycle/IScheduleLifeCycleBuilder.cs
@@ -0,0 +1,16 @@
+﻿using System;
+
+namespace InEngine.Core.Scheduling.LifeCycle
+{
+    public interface IScheduleLifeCycleBuilder
+    {
+        AbstractCommand Command { get; set; }
+        IScheduleLifeCycleBuilder Before(Action<AbstractCommand> action);
+        IScheduleLifeCycleBuilder After(Action<AbstractCommand> action);
+        IScheduleLifeCycleBuilder PingBefore(string url);
+        IScheduleLifeCycleBuilder PingAfter(string url);
+        IScheduleLifeCycleBuilder WriteOutputTo(string output);
+        IScheduleLifeCycleBuilder AppendOutputTo(string output);
+        IScheduleLifeCycleBuilder EmailOutputTo(string emailAddress);
+    }
+}
diff --git a/src/InEngine.Core/Scheduling/LifeCycle/ScheduleLifeCycleBuilder.cs b/src/InEngine.Core/Scheduling/LifeCycle/ScheduleLifeCycleBuilder.cs
@@ -2,7 +2,7 @@
 
 namespace InEngine.Core.Scheduling.LifeCycle
 {
-    public class LifeCycleActions : IScheduleLifeCycleActions
+    public class ScheduleLifeCycleBuilder : IScheduleLifeCycleBuilder
     {
         public AbstractCommand Command { 
             get { return JobRegistration.Command; }
@@ -12,47 +12,47 @@ public AbstractCommand Command {
         public JobRegistration JobRegistration { get; set; }
 
 
-        public IScheduleLifeCycleActions Before(Action<AbstractCommand> action)
+        public IScheduleLifeCycleBuilder Before(Action<AbstractCommand> action)
         {
             JobRegistration.Command.CommandLifeCycle.BeforeAction = action;
             return this;
         }
 
-        public IScheduleLifeCycleActions After(Action<AbstractCommand> action)
+        public IScheduleLifeCycleBuilder After(Action<AbstractCommand> action)
         {
             JobRegistration.Command.CommandLifeCycle.AfterAction = action;
             return this;
         }
 
-        public IScheduleLifeCycleActions PingBefore(string url)
+        public IScheduleLifeCycleBuilder PingBefore(string url)
         {
             JobRegistration.Command.CommandLifeCycle.ShouldPingBefore = true;
             JobRegistration.Command.CommandLifeCycle.PingBeforeUrl = url;
             return this;
         }
 
-        public IScheduleLifeCycleActions PingAfter(string url)
+        public IScheduleLifeCycleBuilder PingAfter(string url)
         {
             JobRegistration.Command.CommandLifeCycle.ShouldPingAfter = true;
             JobRegistration.Command.CommandLifeCycle.PingAfterUrl = url;
             return this;
         }
 
-        public IScheduleLifeCycleActions WriteOutputTo(string output)
+        public IScheduleLifeCycleBuilder WriteOutputTo(string output)
         {
             JobRegistration.Command.CommandLifeCycle.ShouldWriteOutputToFile = true;
             JobRegistration.Command.CommandLifeCycle.WriteOutputToFilePath = output;
             return this;
         }
 
-        public IScheduleLifeCycleActions AppendOutputTo(string output)
+        public IScheduleLifeCycleBuilder AppendOutputTo(string output)
         {
             JobRegistration.Command.CommandLifeCycle.ShouldAppendOutputToFile = true;
             JobRegistration.Command.CommandLifeCycle.AppendOutputToFilePath = output;
             return this;
         }
 
-        public IScheduleLifeCycleActions EmailOutputTo(string emailAddress)
+        public IScheduleLifeCycleBuilder EmailOutputTo(string emailAddress)
         {
             JobRegistration.Command.CommandLifeCycle.ShouldEmailOutput = true;
             JobRegistration.Command.CommandLifeCycle.EmailOutputToAddress = emailAddress;
diff --git a/src/InEngine.Core/Scheduling/Occurence.cs b/src/InEngine.Core/Scheduling/Occurence.cs
@@ -19,78 +19,78 @@ public static TriggerBuilder MakeTriggerBuilder(AbstractCommand command)
                 .WithIdentity($"{command.Name}:job:{command.ScheduleId}", command.SchedulerGroup);
         }
 
-        public LifeCycleActions RegisterJob(Action<DailyTimeIntervalScheduleBuilder> action)
+        public ScheduleLifeCycleBuilder RegisterJob(Action<DailyTimeIntervalScheduleBuilder> action)
         {
-            return new LifeCycleActions { 
+            return new ScheduleLifeCycleBuilder { 
                 JobRegistration = Schedule.RegisterJob(Command, JobDetail, MakeTriggerBuilder(Command).WithDailyTimeIntervalSchedule(action).Build()) 
             };
         }
 
-        public LifeCycleActions RegisterJob(string cronExpression)
+        public ScheduleLifeCycleBuilder RegisterJob(string cronExpression)
         {
-            return new LifeCycleActions {
+            return new ScheduleLifeCycleBuilder {
                 JobRegistration = Schedule.RegisterJob(Command, JobDetail, MakeTriggerBuilder(Command).WithCronSchedule(cronExpression).Build())
             };
         }
 
-        public LifeCycleActions RegisterJob(Action<SimpleScheduleBuilder> action)
+        public ScheduleLifeCycleBuilder RegisterJob(Action<SimpleScheduleBuilder> action)
         {
-            return new LifeCycleActions {
+            return new ScheduleLifeCycleBuilder {
                 JobRegistration = Schedule.RegisterJob(Command, JobDetail, MakeTriggerBuilder(Command).WithSimpleSchedule(action).Build())
             };
         }
 
-        public LifeCycleActions Cron(string cronExpression)
+        public ScheduleLifeCycleBuilder Cron(string cronExpression)
         {
             return RegisterJob(cronExpression);
         }
 
-        public LifeCycleActions EverySecond()
+        public ScheduleLifeCycleBuilder EverySecond()
         {
             return RegisterJob(x => x.WithIntervalInSeconds(1).RepeatForever());
         }
 
-        public LifeCycleActions EveryMinute()
+        public ScheduleLifeCycleBuilder EveryMinute()
         {
             return RegisterJob(x => x.WithIntervalInMinutes(1).RepeatForever());
         }
 
-        public LifeCycleActions EveryFiveMinutes()
+        public ScheduleLifeCycleBuilder EveryFiveMinutes()
         {
             return RegisterJob(x => x.WithIntervalInMinutes(5).RepeatForever());
         }
 
-        public LifeCycleActions EveryTenMinutes()
+        public ScheduleLifeCycleBuilder EveryTenMinutes()
         {
             return RegisterJob(x => x.WithIntervalInMinutes(10).RepeatForever());
         }
 
-        public LifeCycleActions EveryFifteenMinutes()
+        public ScheduleLifeCycleBuilder EveryFifteenMinutes()
         {
             return RegisterJob(x => x.WithIntervalInMinutes(15).RepeatForever());
         }
 
-        public LifeCycleActions EveryThirtyMinutes()
+        public ScheduleLifeCycleBuilder EveryThirtyMinutes()
         {
             return RegisterJob(x => x.WithIntervalInMinutes(30).RepeatForever());
         }
 
-        public LifeCycleActions Hourly()
+        public ScheduleLifeCycleBuilder Hourly()
         {
             return RegisterJob(x => x.WithIntervalInHours(1).RepeatForever());
         }
 
-        public LifeCycleActions HourlyAt(int minutesAfterTheHour)
+        public ScheduleLifeCycleBuilder HourlyAt(int minutesAfterTheHour)
         {
             return RegisterJob($"0 {minutesAfterTheHour} * * * ?");
         }
 
-        public LifeCycleActions Daily()
+        public ScheduleLifeCycleBuilder Daily()
         {
             return RegisterJob(x => x.WithIntervalInHours(24).RepeatForever());
         }
 
-        public LifeCycleActions DailyAt(int hours, int minutes, int seconds = 0)
+        public ScheduleLifeCycleBuilder DailyAt(int hours, int minutes, int seconds = 0)
         {
             return RegisterJob(x => x.StartingDailyAt(new TimeOfDay(hours, minutes, seconds)));
         }

Original file line number	Diff line number	Diff line change
`@@ -9,24 +9,24 @@ namespace InEngine.Core.Queuing`
`9`	`9`	`{`
`10`	`10`	`public static class Enqueue`
`11`	`11`	`{`
`12`		`- public static IQueueLifeCycleActions Command(Expression<Action> expressionAction)`
	`12`	`+ public static IQueueLifeCycleBuilder Command(Expression<Action> expressionAction)`
`13`	`13`	`{`
`14`		`- return new QueueLifeCycleActions(new Lambda(expressionAction.ToExpressionNode()));`
	`14`	`+ return new QueueLifeCycleBuilder(new Lambda(expressionAction.ToExpressionNode()));`
`15`	`15`	`}`
`16`	`16`
`17`		`- public static IQueueLifeCycleActions Command(AbstractCommand command)`
	`17`	`+ public static IQueueLifeCycleBuilder Command(AbstractCommand command)`
`18`	`18`	`{`
`19`		`- return new QueueLifeCycleActions(command);`
	`19`	`+ return new QueueLifeCycleBuilder(command);`
`20`	`20`	`}`
`21`	`21`
`22`		`- public static IQueueLifeCycleActions Command<T>(T command) where T : AbstractCommand`
	`22`	`+ public static IQueueLifeCycleBuilder Command<T>(T command) where T : AbstractCommand`
`23`	`23`	`{`
`24`		`- return new QueueLifeCycleActions(command);`
	`24`	`+ return new QueueLifeCycleBuilder(command);`
`25`	`25`	`}`
`26`	`26`
`27`		`- public static IQueueLifeCycleActions Commands(IList<AbstractCommand> commands)`
	`27`	`+ public static IQueueLifeCycleBuilder Commands(IList<AbstractCommand> commands)`
`28`	`28`	`{`
`29`		`- return new QueueLifeCycleActions(new Chain() { Commands = commands });`
	`29`	`+ return new QueueLifeCycleBuilder(new Chain() { Commands = commands });`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,79 +2,79 @@`
`2`	`2`
`3`	`3`	`namespace InEngine.Core.Queuing.LifeCycle`
`4`	`4`	`{`
`5`		`- public class QueueLifeCycleActions : IQueueLifeCycleActions`
	`5`	`+ public class QueueLifeCycleBuilder : IQueueLifeCycleBuilder`
`6`	`6`	`{`
`7`	`7`	`public AbstractCommand Command { get; set; }`
`8`	`8`	`public QueueAdapter QueueAdapter { get; set; }`
`9`	`9`
`10`		`- public QueueLifeCycleActions()`
	`10`	`+ public QueueLifeCycleBuilder()`
`11`	`11`	`{}`
`12`	`12`
`13`		`- public QueueLifeCycleActions(AbstractCommand command) : this()`
	`13`	`+ public QueueLifeCycleBuilder(AbstractCommand command) : this()`
`14`	`14`	`{`
`15`	`15`	`Command = command;`
`16`	`16`	`}`
`17`	`17`
`18`		`- public IQueueLifeCycleActions Before(Action<AbstractCommand> action)`
	`18`	`+ public IQueueLifeCycleBuilder Before(Action<AbstractCommand> action)`
`19`	`19`	`{`
`20`	`20`	`Command.CommandLifeCycle.BeforeAction = action;`
`21`	`21`	`return this;`
`22`	`22`	`}`
`23`	`23`
`24`		`- public IQueueLifeCycleActions After(Action<AbstractCommand> action)`
	`24`	`+ public IQueueLifeCycleBuilder After(Action<AbstractCommand> action)`
`25`	`25`	`{`
`26`	`26`	`Command.CommandLifeCycle.AfterAction = action;`
`27`	`27`	`return this;`
`28`	`28`	`}`
`29`	`29`
`30`		`- public IQueueLifeCycleActions PingBefore(string url)`
	`30`	`+ public IQueueLifeCycleBuilder PingBefore(string url)`
`31`	`31`	`{`
`32`	`32`	`Command.CommandLifeCycle.ShouldPingBefore = true;`
`33`	`33`	`Command.CommandLifeCycle.PingBeforeUrl = url;`
`34`	`34`	`return this;`
`35`	`35`	`}`
`36`	`36`
`37`		`- public IQueueLifeCycleActions PingAfter(string url)`
	`37`	`+ public IQueueLifeCycleBuilder PingAfter(string url)`
`38`	`38`	`{`
`39`	`39`	`Command.CommandLifeCycle.ShouldPingAfter = true;`
`40`	`40`	`Command.CommandLifeCycle.PingAfterUrl = url;`
`41`	`41`	`return this;`
`42`	`42`	`}`
`43`	`43`
`44`		`- public IQueueLifeCycleActions WriteOutputTo(string output)`
	`44`	`+ public IQueueLifeCycleBuilder WriteOutputTo(string output)`
`45`	`45`	`{`
`46`	`46`	`Command.CommandLifeCycle.ShouldWriteOutputToFile = true;`
`47`	`47`	`Command.CommandLifeCycle.WriteOutputToFilePath = output;`
`48`	`48`	`return this;`
`49`	`49`	`}`
`50`	`50`
`51`		`- public IQueueLifeCycleActions AppendOutputTo(string output)`
	`51`	`+ public IQueueLifeCycleBuilder AppendOutputTo(string output)`
`52`	`52`	`{`
`53`	`53`	`Command.CommandLifeCycle.ShouldAppendOutputToFile = true;`
`54`	`54`	`Command.CommandLifeCycle.AppendOutputToFilePath = output;`
`55`	`55`	`return this;`
`56`	`56`	`}`
`57`	`57`
`58`		`- public IQueueLifeCycleActions EmailOutputTo(string emailAddress)`
	`58`	`+ public IQueueLifeCycleBuilder EmailOutputTo(string emailAddress)`
`59`	`59`	`{`
`60`	`60`	`Command.CommandLifeCycle.ShouldEmailOutput = true;`
`61`	`61`	`Command.CommandLifeCycle.EmailOutputToAddress = emailAddress;`
`62`	`62`	`return this;`
`63`	`63`	`}`
`64`	`64`
`65`		`- public IQueueLifeCycleActions ToPrimaryQueue()`
	`65`	`+ public IQueueLifeCycleBuilder ToPrimaryQueue()`
`66`	`66`	`{`
`67`	`67`	`QueueAdapter = QueueAdapter.Make(false);`
`68`	`68`	`return this;`
`69`	`69`	`}`
`70`	`70`
`71`		`- public IQueueLifeCycleActions ToSecondaryQueue()`
	`71`	`+ public IQueueLifeCycleBuilder ToSecondaryQueue()`
`72`	`72`	`{`
`73`	`73`	`QueueAdapter = QueueAdapter.Make(true);`
`74`	`74`	`return this;`
`75`	`75`	`}`
`76`	`76`
`77`		`- public IQueueLifeCycleActions WithRetries(int maximumRetries)`
	`77`	`+ public IQueueLifeCycleBuilder WithRetries(int maximumRetries)`
`78`	`78`	`{`
`79`	`79`	`Command.CommandLifeCycle.MaximumRetries = maximumRetries;`
`80`	`80`	`return this;`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`namespace InEngine.Core.Scheduling.LifeCycle`
`4`	`4`	`{`
`5`		`- public class LifeCycleActions : IScheduleLifeCycleActions`
	`5`	`+ public class ScheduleLifeCycleBuilder : IScheduleLifeCycleBuilder`
`6`	`6`	`{`
`7`	`7`	`public AbstractCommand Command {`
`8`	`8`	`get { return JobRegistration.Command; }`
`@@ -12,47 +12,47 @@ public AbstractCommand Command {`
`12`	`12`	`public JobRegistration JobRegistration { get; set; }`
`13`	`13`
`14`	`14`
`15`		`- public IScheduleLifeCycleActions Before(Action<AbstractCommand> action)`
	`15`	`+ public IScheduleLifeCycleBuilder Before(Action<AbstractCommand> action)`
`16`	`16`	`{`
`17`	`17`	`JobRegistration.Command.CommandLifeCycle.BeforeAction = action;`
`18`	`18`	`return this;`
`19`	`19`	`}`
`20`	`20`
`21`		`- public IScheduleLifeCycleActions After(Action<AbstractCommand> action)`
	`21`	`+ public IScheduleLifeCycleBuilder After(Action<AbstractCommand> action)`
`22`	`22`	`{`
`23`	`23`	`JobRegistration.Command.CommandLifeCycle.AfterAction = action;`
`24`	`24`	`return this;`
`25`	`25`	`}`
`26`	`26`
`27`		`- public IScheduleLifeCycleActions PingBefore(string url)`
	`27`	`+ public IScheduleLifeCycleBuilder PingBefore(string url)`
`28`	`28`	`{`
`29`	`29`	`JobRegistration.Command.CommandLifeCycle.ShouldPingBefore = true;`
`30`	`30`	`JobRegistration.Command.CommandLifeCycle.PingBeforeUrl = url;`
`31`	`31`	`return this;`
`32`	`32`	`}`
`33`	`33`
`34`		`- public IScheduleLifeCycleActions PingAfter(string url)`
	`34`	`+ public IScheduleLifeCycleBuilder PingAfter(string url)`
`35`	`35`	`{`
`36`	`36`	`JobRegistration.Command.CommandLifeCycle.ShouldPingAfter = true;`
`37`	`37`	`JobRegistration.Command.CommandLifeCycle.PingAfterUrl = url;`
`38`	`38`	`return this;`
`39`	`39`	`}`
`40`	`40`
`41`		`- public IScheduleLifeCycleActions WriteOutputTo(string output)`
	`41`	`+ public IScheduleLifeCycleBuilder WriteOutputTo(string output)`
`42`	`42`	`{`
`43`	`43`	`JobRegistration.Command.CommandLifeCycle.ShouldWriteOutputToFile = true;`
`44`	`44`	`JobRegistration.Command.CommandLifeCycle.WriteOutputToFilePath = output;`
`45`	`45`	`return this;`
`46`	`46`	`}`
`47`	`47`
`48`		`- public IScheduleLifeCycleActions AppendOutputTo(string output)`
	`48`	`+ public IScheduleLifeCycleBuilder AppendOutputTo(string output)`
`49`	`49`	`{`
`50`	`50`	`JobRegistration.Command.CommandLifeCycle.ShouldAppendOutputToFile = true;`
`51`	`51`	`JobRegistration.Command.CommandLifeCycle.AppendOutputToFilePath = output;`
`52`	`52`	`return this;`
`53`	`53`	`}`
`54`	`54`
`55`		`- public IScheduleLifeCycleActions EmailOutputTo(string emailAddress)`
	`55`	`+ public IScheduleLifeCycleBuilder EmailOutputTo(string emailAddress)`
`56`	`56`	`{`
`57`	`57`	`JobRegistration.Command.CommandLifeCycle.ShouldEmailOutput = true;`
`58`	`58`	`JobRegistration.Command.CommandLifeCycle.EmailOutputToAddress = emailAddress;`
Original file line number	Diff line number	Diff line change
`@@ -19,78 +19,78 @@ public static TriggerBuilder MakeTriggerBuilder(AbstractCommand command)`
`19`	`19`	`.WithIdentity($"{command.Name}:job:{command.ScheduleId}", command.SchedulerGroup);`
`20`	`20`	`}`
`21`	`21`
`22`		`- public LifeCycleActions RegisterJob(Action<DailyTimeIntervalScheduleBuilder> action)`
	`22`	`+ public ScheduleLifeCycleBuilder RegisterJob(Action<DailyTimeIntervalScheduleBuilder> action)`
`23`	`23`	`{`
`24`		`- return new LifeCycleActions {`
	`24`	`+ return new ScheduleLifeCycleBuilder {`
`25`	`25`	`JobRegistration = Schedule.RegisterJob(Command, JobDetail, MakeTriggerBuilder(Command).WithDailyTimeIntervalSchedule(action).Build())`
`26`	`26`	`};`
`27`	`27`	`}`
`28`	`28`
`29`		`- public LifeCycleActions RegisterJob(string cronExpression)`
	`29`	`+ public ScheduleLifeCycleBuilder RegisterJob(string cronExpression)`
`30`	`30`	`{`
`31`		`- return new LifeCycleActions {`
	`31`	`+ return new ScheduleLifeCycleBuilder {`
`32`	`32`	`JobRegistration = Schedule.RegisterJob(Command, JobDetail, MakeTriggerBuilder(Command).WithCronSchedule(cronExpression).Build())`
`33`	`33`	`};`
`34`	`34`	`}`
`35`	`35`
`36`		`- public LifeCycleActions RegisterJob(Action<SimpleScheduleBuilder> action)`
	`36`	`+ public ScheduleLifeCycleBuilder RegisterJob(Action<SimpleScheduleBuilder> action)`
`37`	`37`	`{`
`38`		`- return new LifeCycleActions {`
	`38`	`+ return new ScheduleLifeCycleBuilder {`
`39`	`39`	`JobRegistration = Schedule.RegisterJob(Command, JobDetail, MakeTriggerBuilder(Command).WithSimpleSchedule(action).Build())`
`40`	`40`	`};`
`41`	`41`	`}`
`42`	`42`
`43`		`- public LifeCycleActions Cron(string cronExpression)`
	`43`	`+ public ScheduleLifeCycleBuilder Cron(string cronExpression)`
`44`	`44`	`{`
`45`	`45`	`return RegisterJob(cronExpression);`
`46`	`46`	`}`
`47`	`47`
`48`		`- public LifeCycleActions EverySecond()`
	`48`	`+ public ScheduleLifeCycleBuilder EverySecond()`
`49`	`49`	`{`
`50`	`50`	`return RegisterJob(x => x.WithIntervalInSeconds(1).RepeatForever());`
`51`	`51`	`}`
`52`	`52`
`53`		`- public LifeCycleActions EveryMinute()`
	`53`	`+ public ScheduleLifeCycleBuilder EveryMinute()`
`54`	`54`	`{`
`55`	`55`	`return RegisterJob(x => x.WithIntervalInMinutes(1).RepeatForever());`
`56`	`56`	`}`
`57`	`57`
`58`		`- public LifeCycleActions EveryFiveMinutes()`
	`58`	`+ public ScheduleLifeCycleBuilder EveryFiveMinutes()`
`59`	`59`	`{`
`60`	`60`	`return RegisterJob(x => x.WithIntervalInMinutes(5).RepeatForever());`
`61`	`61`	`}`
`62`	`62`
`63`		`- public LifeCycleActions EveryTenMinutes()`
	`63`	`+ public ScheduleLifeCycleBuilder EveryTenMinutes()`
`64`	`64`	`{`
`65`	`65`	`return RegisterJob(x => x.WithIntervalInMinutes(10).RepeatForever());`
`66`	`66`	`}`
`67`	`67`
`68`		`- public LifeCycleActions EveryFifteenMinutes()`
	`68`	`+ public ScheduleLifeCycleBuilder EveryFifteenMinutes()`
`69`	`69`	`{`
`70`	`70`	`return RegisterJob(x => x.WithIntervalInMinutes(15).RepeatForever());`
`71`	`71`	`}`
`72`	`72`
`73`		`- public LifeCycleActions EveryThirtyMinutes()`
	`73`	`+ public ScheduleLifeCycleBuilder EveryThirtyMinutes()`
`74`	`74`	`{`
`75`	`75`	`return RegisterJob(x => x.WithIntervalInMinutes(30).RepeatForever());`
`76`	`76`	`}`
`77`	`77`
`78`		`- public LifeCycleActions Hourly()`
	`78`	`+ public ScheduleLifeCycleBuilder Hourly()`
`79`	`79`	`{`
`80`	`80`	`return RegisterJob(x => x.WithIntervalInHours(1).RepeatForever());`
`81`	`81`	`}`
`82`	`82`
`83`		`- public LifeCycleActions HourlyAt(int minutesAfterTheHour)`
	`83`	`+ public ScheduleLifeCycleBuilder HourlyAt(int minutesAfterTheHour)`
`84`	`84`	`{`
`85`	`85`	`return RegisterJob($"0 {minutesAfterTheHour} * * * ?");`
`86`	`86`	`}`
`87`	`87`
`88`		`- public LifeCycleActions Daily()`
	`88`	`+ public ScheduleLifeCycleBuilder Daily()`
`89`	`89`	`{`
`90`	`90`	`return RegisterJob(x => x.WithIntervalInHours(24).RepeatForever());`
`91`	`91`	`}`
`92`	`92`
`93`		`- public LifeCycleActions DailyAt(int hours, int minutes, int seconds = 0)`
	`93`	`+ public ScheduleLifeCycleBuilder DailyAt(int hours, int minutes, int seconds = 0)`
`94`	`94`	`{`
`95`	`95`	`return RegisterJob(x => x.StartingDailyAt(new TimeOfDay(hours, minutes, seconds)));`
`96`	`96`	`}`