public async Task <ScheduledRecurringMessage> ScheduleRecurringSend(IRecurringMessageScheduler scheduler, Uri destinationAddress,
RecurringSchedule schedule, object message, CancellationToken cancellationToken)
{
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
if (schedule == null)
{
throw new ArgumentNullException(nameof(schedule));
}
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var msg = message as T;
if (msg == null)
{
throw new ArgumentException("Unexpected message type: " + message.GetType().GetTypeName());
}
ScheduledRecurringMessage <T> scheduleSend = await scheduler.ScheduleRecurringSend(destinationAddress, schedule, msg, cancellationToken)
.ConfigureAwait(false);
return(scheduleSend);
}
ITrigger CreateTrigger(RecurringSchedule message, IJobDetail jobDetail, TriggerKey triggerKey)
{
TimeZoneInfo tz = TimeZoneInfo.Local;
if (!string.IsNullOrWhiteSpace(message.TimeZoneId) && message.TimeZoneId != tz.Id)
{
tz = TimeZoneInfo.FindSystemTimeZoneById(message.TimeZoneId);
}
TriggerBuilder triggerBuilder = TriggerBuilder.Create()
.ForJob(jobDetail)
.WithIdentity(triggerKey)
.StartAt(message.StartTime)
.WithCronSchedule(message.CronExpression, x =>
{
x.InTimeZone(tz);
switch (message.MisfirePolicy)
{
case MissedEventPolicy.Skip:
x.WithMisfireHandlingInstructionDoNothing();
break;
case MissedEventPolicy.Send:
x.WithMisfireHandlingInstructionFireAndProceed();
break;
}
});
if (message.EndTime.HasValue)
{
triggerBuilder.EndAt(message.EndTime);
}
return(triggerBuilder.Build());
}
public void Event_Match_RecurringSchedule()
{
RecurringSchedule schedule = new RecurringSchedule("회의", DayOfWeek.Saturday, DateTime.Today.AddHours(10).AddMinutes(30), TimeSpan.FromMinutes(30));
Event meeting = new Event("회의", new DateTime(2022, 4, 2, 10, 30, 0), TimeSpan.FromMinutes(30));
Assert.IsTrue(meeting.IsSatisfied(schedule));
}
private async Task <TResult> RunServicesAsync <TResult>(BackupAction action, RecurringSchedule schedule, Func <string[], TResult> onCompleted)
{
if (action.services == null || !action.services.Any())
{
return(onCompleted(new string[] { $"no services for {action.tag}" }));
}
if (!action.GetSourceAccount(out CloudStorageAccount sourceAccount))
{
return(onCompleted(new[] { $"bad SOURCE connection string for {action.tag}" }));
}
if (!schedule.GetTargetAccount(out CloudStorageAccount targetAccount))
{
return(onCompleted(new[] { $"bad TARGET connection string for {schedule.tag}" }));
}
var errors = new string[] { };
if (action.services.Contains(StorageService.Table))
{
errors = errors
.Concat(await action.serviceSettings.table.CopyAccountAsync(sourceAccount, targetAccount, StopCalled, msgs => msgs))
.ToArray();
}
if (action.services.Contains(StorageService.Blob))
{
errors = errors
.Concat(await action.serviceSettings.blob.CopyAccountAsync(sourceAccount, targetAccount, StopCalled, msgs => msgs))
.ToArray();
}
return(onCompleted(errors));
}
public async Task <ScheduledRecurringMessage> ScheduleRecurringSend(IRecurringMessageScheduler scheduler, Uri destinationAddress,
RecurringSchedule schedule, object message, IPipe <SendContext> pipe, CancellationToken cancellationToken)
{
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
if (schedule == null)
{
throw new ArgumentNullException(nameof(schedule));
}
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (pipe == null)
{
throw new ArgumentNullException(nameof(pipe));
}
if (message is T msg)
{
return(await scheduler.ScheduleRecurringSend(destinationAddress, schedule, msg, pipe, cancellationToken).ConfigureAwait(false));
}
throw new ArgumentException("Unexpected message type: " + TypeMetadataCache.GetShortName(message.GetType()));
}
public async Task AddNewRecurringSchedule(Schedule schedule, RecurringSchedule recurringSchedule)
{
recurringSchedule.Status = ScheduleStatus.NotAvailable;
recurringSchedule.ScheduleId = schedule.Id;
schedule.RecurringSchedules.Add(recurringSchedule);
await Client.PutJsonAsync($"/api/schedule/{schedule.Id}", schedule);
}
public void RecurringSchedule()
{
RecurringSchedule schedule = new RecurringSchedule("회의", DayOfWeek.Saturday, DateTime.Today.AddHours(10).AddMinutes(30), TimeSpan.FromMinutes(30));
Assert.AreEqual(schedule.DayOfWeek, DayOfWeek.Saturday);
Assert.AreEqual(schedule.From.Hour, 10);
Assert.AreEqual(schedule.From.Minute, 30);
Assert.AreEqual(schedule.Duration, TimeSpan.FromMinutes(30));
}
public ScheduleRecurringMessageCommand(RecurringSchedule schedule, Uri destination, T payload)
{
CorrelationId = NewId.NextGuid();
Schedule = schedule;
Destination = destination;
Payload = payload;
PayloadType = TypeMetadataCache <T> .MessageTypeNames;
}
/// <summary>
/// Schedules a message to be sent to the bus using a Publish, which should only be used when
/// the quartz service is on a single shared queue or behind a distributor
/// </summary>
/// <typeparam name="T">The scheduled message type</typeparam>
/// <param name="bus">The bus from which the scheduled message command should be published</param>
/// <param name="schedule">An instance of IRecurringSchedule that defines this schedule</param>
/// <param name="message">The message to send</param>
/// <param name="contextCallback">Optional: A callback that gives the caller access to the publish context.</param>
/// <returns>A handled to the scheduled message</returns>
public static Task <ScheduledRecurringMessage <T> > ScheduleRecurringMessage <T>(this IBus bus, RecurringSchedule schedule, T message,
IPipe <PublishContext <ScheduleRecurringMessage <T> > > contextCallback = null)
where T : class
{
return(ScheduleRecurringMessage(bus, bus.Address, schedule, message, contextCallback));
}
private static void ProceedRecurringScheduleToDal(RecurringSchedule item, ArticleScheduleDAL result)
{
result.ActiveStartDate = ScheduleHelper.GetSqlValuesFromScheduleDate(item.RepetitionStartDate);
result.ActiveStartTime = ScheduleHelper.GetSqlValuesFromScheduleTime(item.ShowStartTime);
var repetitionEndDate = item.RepetitionNoEnd ? ArticleScheduleConstants.Infinity.Date : item.RepetitionEndDate;
var repetitionEndTime = item.ShowLimitationType == ShowLimitationType.Duration ? ArticleScheduleConstants.Infinity.TimeOfDay : item.ShowEndTime;
result.ActiveEndDate = ScheduleHelper.GetSqlValuesFromScheduleDate(repetitionEndDate);
result.ActiveEndTime = ScheduleHelper.GetSqlValuesFromScheduleTime(repetitionEndTime);
result.UseDuration = item.ShowLimitationType == ShowLimitationType.Duration ? 1 : 0;
result.Duration = Convert.ToDecimal(item.DurationValue);
result.DurationUnits = item.DurationUnit.ToDbValue();
if (item.ScheduleRecurringType == ScheduleRecurringType.Daily)
{
result.FreqInterval = item.ScheduleRecurringValue;
}
else if (item.ScheduleRecurringType == ScheduleRecurringType.Weekly)
{
result.FreqRecurrenceFactor = item.ScheduleRecurringValue;
result.FreqInterval = 0;
if (item.OnSunday)
{
result.FreqInterval = result.FreqInterval | 1;
}
if (item.OnMonday)
{
result.FreqInterval = result.FreqInterval | 2;
}
if (item.OnTuesday)
{
result.FreqInterval = result.FreqInterval | 4;
}
if (item.OnWednesday)
{
result.FreqInterval = result.FreqInterval | 8;
}
if (item.OnThursday)
{
result.FreqInterval = result.FreqInterval | 16;
}
if (item.OnFriday)
{
result.FreqInterval = result.FreqInterval | 32;
}
if (item.OnSaturday)
{
result.FreqInterval = result.FreqInterval | 64;
}
}
else if (item.ScheduleRecurringType == ScheduleRecurringType.Monthly || item.ScheduleRecurringType == ScheduleRecurringType.Yearly)
{
if (item.ScheduleRecurringType == ScheduleRecurringType.Yearly)
{
result.FreqRecurrenceFactor = item.ScheduleRecurringValue * 12;
var dt = new DateTime(item.RepetitionStartDate.Year, item.Month, 1);
if (dt < DateTime.Now.Date)
{
dt = dt.AddYears(1);
}
result.ActiveStartDate = ScheduleHelper.GetSqlValuesFromScheduleDate(dt);
}
else if (item.ScheduleRecurringType == ScheduleRecurringType.Monthly)
{
result.FreqRecurrenceFactor = item.ScheduleRecurringValue;
}
if (item.DaySpecifyingType == DaySpecifyingType.Date) // Month
{
result.FreqInterval = item.DayOfMonth;
}
else if (item.DaySpecifyingType == DaySpecifyingType.DayOfWeek) // MonthRelative
{
result.FreqRelativeInterval = (int)item.WeekOfMonth;
result.FreqInterval = (int)item.DayOfWeek;
}
}
}
Task <ScheduledRecurringMessage> IRecurringMessageScheduler.ScheduleRecurringSend(Uri destinationAddress, RecurringSchedule schedule, object message,
CancellationToken cancellationToken)
{
if (destinationAddress == null)
{
throw new ArgumentNullException(nameof(destinationAddress));
}
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var messageType = message.GetType();
return(MessageSchedulerConverterCache.ScheduleRecurringSend(this, destinationAddress, schedule, message, messageType, cancellationToken));
}
public static Task<ScheduledRecurringMessage> ScheduleRecurringSend(IRecurringMessageScheduler scheduler, Uri destinationAddress, RecurringSchedule schedule, object message,
Type messageType, CancellationToken cancellationToken)
{
return Cached.Converters.Value[messageType].ScheduleRecurringSend(scheduler, destinationAddress, schedule, message, cancellationToken);
}
private int DaysDistance(RecurringSchedule schedule) => schedule.DayOfWeek - from.DayOfWeek;
Task <ScheduledRecurringMessage <T> > IRecurringMessageScheduler.ScheduleRecurringSend <T>(Uri destinationAddress, RecurringSchedule schedule, T message,
IPipe <SendContext> pipe,
CancellationToken cancellationToken)
{
if (destinationAddress == null)
{
throw new ArgumentNullException(nameof(destinationAddress));
}
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (pipe == null)
{
throw new ArgumentNullException(nameof(pipe));
}
return(ScheduleRecurringSend(destinationAddress, schedule, message, pipe, cancellationToken));
}
/// <summary>
/// Updates the local task object from the UI elements.
/// </summary>
private void UpdateTaskFromUI()
{
//Set the name of the task
task.Name = name.Text;
//And the schedule, if selected.
if (typeManual.Checked)
{
task.Schedule = Schedule.RunManually;
}
else if (typeImmediate.Checked)
{
task.Schedule = Schedule.RunNow;
}
else if (typeRestart.Checked)
{
task.Schedule = Schedule.RunOnRestart;
}
else if (typeRecurring.Checked)
{
RecurringSchedule schedule = new RecurringSchedule();
schedule.ExecutionTime = new DateTime(1, 1, 1, scheduleTime.Value.Hour,
scheduleTime.Value.Minute, scheduleTime.Value.Second);
if (scheduleDaily.Checked)
{
if (scheduleDailyByDay.Checked)
{
schedule.ScheduleType = RecurringScheduleUnit.Daily;
schedule.Frequency = (int)scheduleDailyByDayFreq.Value;
}
else
{
schedule.ScheduleType = RecurringScheduleUnit.Weekdays;
}
}
else if (scheduleWeekly.Checked)
{
schedule.ScheduleType = RecurringScheduleUnit.Weekly;
schedule.Frequency = (int)scheduleWeeklyFreq.Value;
DaysOfWeek weeklySchedule = 0;
if (scheduleWeeklyMonday.Checked)
{
weeklySchedule |= DaysOfWeek.Monday;
}
if (scheduleWeeklyTuesday.Checked)
{
weeklySchedule |= DaysOfWeek.Tuesday;
}
if (scheduleWeeklyWednesday.Checked)
{
weeklySchedule |= DaysOfWeek.Wednesday;
}
if (scheduleWeeklyThursday.Checked)
{
weeklySchedule |= DaysOfWeek.Thursday;
}
if (scheduleWeeklyFriday.Checked)
{
weeklySchedule |= DaysOfWeek.Friday;
}
if (scheduleWeeklySaturday.Checked)
{
weeklySchedule |= DaysOfWeek.Saturday;
}
if (scheduleWeeklySunday.Checked)
{
weeklySchedule |= DaysOfWeek.Sunday;
}
schedule.WeeklySchedule = weeklySchedule;
}
else if (scheduleMonthly.Checked)
{
schedule.ScheduleType = RecurringScheduleUnit.Monthly;
schedule.Frequency = (int)scheduleMonthlyFreq.Value;
schedule.MonthlySchedule = (int)scheduleMonthlyDayNumber.Value;
}
else
{
throw new ArgumentException("No such scheduling method.");
}
task.Schedule = schedule;
}
}
/// <summary>
/// Schedules a recurring message to be sent to the bus using a Publish, which should only be used when
/// the quartz service is on a single shared queue or behind a distributor
/// </summary>
/// <typeparam name="T">The scheduled message type</typeparam>
/// <param name="publishEndpoint">The bus from which the scheduled message command should be published</param>
/// <param name="destinationAddress">The destination address where the schedule message should be sent</param>
/// <param name="schedule">The recurring schedule instance</param>
/// <param name="message">The message to send</param>
/// <param name="contextCallback">Optional: A callback that gives the caller access to the publish context.</param>
/// <returns>A handled to the scheduled message</returns>
public static async Task <ScheduledRecurringMessage <T> > ScheduleRecurringMessage <T>(this IPublishEndpoint publishEndpoint, Uri destinationAddress,
RecurringSchedule schedule, T message, IPipe <PublishContext <ScheduleRecurringMessage <T> > > contextCallback = null)
where T : class
{
var command = new ScheduleRecurringMessageCommand <T>(schedule, destinationAddress, message);
await publishEndpoint.Publish(command, contextCallback ?? Pipe.Empty <PublishContext <ScheduleRecurringMessage <T> > >()).ConfigureAwait(false);
return(new ScheduledRecurringMessageHandle <T>(command.Schedule, command.Destination, command.Payload));
}
public ScheduledRecurringMessageHandle(RecurringSchedule schedule, Uri destination, T payload)
{
Schedule = schedule;
Destination = destination;
Payload = payload;
}
async Task <ScheduledRecurringMessage <T> > ScheduleRecurringSend <T>(Uri destinationAddress, RecurringSchedule schedule, Task <T> message,
IPipe <SendContext <T> > pipe,
CancellationToken cancellationToken)
where T : class
{
var command = await CreateCommand(destinationAddress, schedule, message).ConfigureAwait(false);
await _publishEndpoint.Publish(command, pipe, cancellationToken).ConfigureAwait(false);
return(new ScheduledRecurringMessageHandle <T>(schedule, command.Destination, command.Payload));
}
Task <ScheduledRecurringMessage <T> > IRecurringMessageScheduler.ScheduleRecurringSend <T>(Uri destinationAddress, RecurringSchedule schedule,
object values,
CancellationToken cancellationToken)
{
if (destinationAddress == null)
{
throw new ArgumentNullException(nameof(destinationAddress));
}
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
var message = MessageInitializerCache <T> .InitializeMessage(values, cancellationToken);
return(ScheduleRecurringSend(destinationAddress, schedule, message, cancellationToken));
}
async Task <ScheduledRecurringMessage <T> > ScheduleRecurringSend <T>(Uri destinationAddress, RecurringSchedule schedule, Task <T> message,
CancellationToken cancellationToken)
where T : class
{
ScheduleRecurringMessage <T> command = await CreateCommand(destinationAddress, schedule, message).ConfigureAwait(false);
var endpoint = await _schedulerEndpoint().ConfigureAwait(false);
await endpoint.Send <ScheduleRecurringMessage>(command, cancellationToken).ConfigureAwait(false);
return(new ScheduledRecurringMessageHandle <T>(schedule, command.Destination, command.Payload));
}
/// <summary>
/// Cancel a scheduled recurring message using the id and group of the schedule class.
/// </summary>
/// <param name="bus"></param>
/// <param name="scheduleId"></param>
/// <param name="scheduleGroup"></param>
public static Task CancelScheduledRecurringMessage(this IPublishEndpoint bus, RecurringSchedule schedule)
{
if (schedule == null)
{
throw new ArgumentNullException(nameof(schedule));
}
return(CancelScheduledRecurringMessage(bus, schedule.ScheduleId, schedule.ScheduleGroup));
}
/// <summary>
/// Updates the UI elements to reflect the data in the Task object.
/// </summary>
private void UpdateUIFromTask()
{
//Set the name of the task
name.Text = task.Name;
//And the schedule, if selected.
if (task.Schedule == Schedule.RunManually)
{
typeManual.Checked = true;
}
else if (task.Schedule == Schedule.RunNow)
{
typeImmediate.Checked = true;
}
else if (task.Schedule == Schedule.RunOnRestart)
{
typeRestart.Checked = true;
}
else
{
typeRecurring.Checked = true;
RecurringSchedule schedule = (RecurringSchedule)task.Schedule;
scheduleTime.Value = scheduleTime.MinDate.Add(schedule.ExecutionTime.TimeOfDay);
switch (schedule.ScheduleType)
{
case RecurringScheduleUnit.Daily:
scheduleDaily.Checked = true;
scheduleDailyByDay.Checked = true;
scheduleDailyByDayFreq.Value = schedule.Frequency;
break;
case RecurringScheduleUnit.Weekdays:
scheduleDaily.Checked = true;
scheduleDailyByWeekday.Checked = true;
break;
case RecurringScheduleUnit.Weekly:
scheduleWeeklyFreq.Value = schedule.Frequency;
scheduleWeekly.Checked = true;
scheduleWeeklyMonday.Checked =
(schedule.WeeklySchedule & DaysOfWeek.Monday) != 0;
scheduleWeeklyTuesday.Checked =
(schedule.WeeklySchedule & DaysOfWeek.Tuesday) != 0;
scheduleWeeklyWednesday.Checked =
(schedule.WeeklySchedule & DaysOfWeek.Wednesday) != 0;
scheduleWeeklyThursday.Checked =
(schedule.WeeklySchedule & DaysOfWeek.Thursday) != 0;
scheduleWeeklyFriday.Checked =
(schedule.WeeklySchedule & DaysOfWeek.Friday) != 0;
scheduleWeeklySaturday.Checked =
(schedule.WeeklySchedule & DaysOfWeek.Saturday) != 0;
scheduleWeeklySunday.Checked =
(schedule.WeeklySchedule & DaysOfWeek.Sunday) != 0;
break;
case RecurringScheduleUnit.Monthly:
scheduleMonthly.Checked = true;
scheduleMonthlyFreq.Value = schedule.Frequency;
scheduleMonthlyDayNumber.Value = schedule.MonthlySchedule;
break;
default:
throw new ArgumentException("Unknown schedule type.");
}
}
//Set the number of targets in the task.
data.VirtualListSize = task.Targets.Count;
}
/// <summary>
/// Schedule a message for recurring delivery using the specified schedule
/// </summary>
/// <typeparam name="T">The message type</typeparam>
/// <param name="endpoint">The message scheduler endpoint</param>
/// <param name="message">The message</param>
/// <param name="destinationAddress">The destination address where the schedule message should be sent</param>
/// <param name="schedule">The schedule for the message to be delivered</param>
/// <param name="pipe"></param>
/// <param name="cancellationToken"></param>
/// <returns>The task which is completed once the Send is acknowledged by the broker</returns>
public static Task <ScheduledRecurringMessage <T> > ScheduleRecurringSend <T>(this IPublishEndpoint endpoint, Uri destinationAddress,
RecurringSchedule schedule, T message,
IPipe <SendContext> pipe, CancellationToken cancellationToken = default)
where T : class
{
IRecurringMessageScheduler scheduler = new PublishRecurringMessageScheduler(endpoint);
return(scheduler.ScheduleRecurringSend(destinationAddress, schedule, message, pipe, cancellationToken));
}
static async Task <ScheduleRecurringMessage <T> > CreateCommand <T>(Uri destinationAddress, RecurringSchedule schedule, Task <T> message)
where T : class
{
var payload = await message.ConfigureAwait(false);
return(new ScheduleRecurringMessageCommand <T>(schedule, destinationAddress, payload));
}
public static async Task <ScheduledRecurringMessage <T> > ScheduleRecurringSend <T>(this ISendEndpoint endpoint, Uri destinationAddress,
RecurringSchedule schedule, T message)
where T : class
{
var command = new ScheduleRecurringMessageCommand <T>(schedule, destinationAddress, message);
await endpoint.Send <ScheduleRecurringMessage <T> >(command).ConfigureAwait(false);
return(new ScheduledRecurringMessageHandle <T>(command.Schedule, command.Destination, command.Payload));
}
/// <summary>
/// Schedule a message for recurring delivery using the specified schedule
/// </summary>
/// <typeparam name="T">The interface type to send</typeparam>
/// <param name="endpoint">The message scheduler endpoint</param>
/// <param name="values">The property values to initialize on the interface</param>
/// <param name="destinationAddress">The destination address where the schedule message should be sent</param>
/// <param name="schedule">The schedule for the message to be delivered</param>
/// <param name="cancellationToken"></param>
/// <returns>The task which is completed once the Send is acknowledged by the broker</returns>
public static Task <ScheduledRecurringMessage <T> > ScheduleRecurringSend <T>(this IPublishEndpoint endpoint, Uri destinationAddress,
RecurringSchedule schedule, object values, CancellationToken cancellationToken = default)
where T : class
{
IRecurringMessageScheduler scheduler = new PublishRecurringMessageScheduler(endpoint);
return(scheduler.ScheduleRecurringSend <T>(destinationAddress, schedule, values, cancellationToken));
}
Task <ScheduledRecurringMessage <T> > IRecurringMessageScheduler.ScheduleRecurringSend <T>(Uri destinationAddress, RecurringSchedule schedule, T message,
CancellationToken cancellationToken)
{
if (destinationAddress == null)
{
throw new ArgumentNullException(nameof(destinationAddress));
}
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
return(ScheduleRecurringSend(destinationAddress, schedule, Task.FromResult(message), cancellationToken));
}
/// <summary>
/// Schedule a message for recurring delivery using the specified schedule
/// </summary>
/// <param name="endpoint">The message scheduler endpoint</param>
/// <param name="message">The message object</param>
/// <param name="destinationAddress">The destination address where the schedule message should be sent</param>
/// <param name="schedule">The schedule for the message to be delivered</param>
/// <param name="cancellationToken"></param>
/// <returns>The task which is completed once the Send is acknowledged by the broker</returns>
public static Task <ScheduledRecurringMessage> ScheduleRecurringSend(this IPublishEndpoint endpoint, Uri destinationAddress, RecurringSchedule schedule,
object message, CancellationToken cancellationToken = default)
{
IRecurringMessageScheduler scheduler = new PublishRecurringMessageScheduler(endpoint);
return(scheduler.ScheduleRecurringSend(destinationAddress, schedule, message, cancellationToken));
}
Task <ScheduledRecurringMessage <T> > IRecurringMessageScheduler.ScheduleRecurringSend <T>(Uri destinationAddress, RecurringSchedule schedule, object values,
IPipe <SendContext> pipe,
CancellationToken cancellationToken)
{
if (destinationAddress == null)
{
throw new ArgumentNullException(nameof(destinationAddress));
}
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
if (pipe == null)
{
throw new ArgumentNullException(nameof(pipe));
}
var message = TypeMetadataCache <T> .InitializeFromObject(values);
return(ScheduleRecurringSend(destinationAddress, schedule, message, pipe, cancellationToken));
}
async Task <ScheduledRecurringMessage <T> > ScheduleRecurringSend <T>(Uri destinationAddress, RecurringSchedule schedule, T message,
IPipe <SendContext <T> > pipe,
CancellationToken cancellationToken)
where T : class
{
ScheduleRecurringMessage <T> command = new ScheduleRecurringMessageCommand <T>(schedule, destinationAddress, message);
var endpoint = await _schedulerEndpoint.Value.ConfigureAwait(false);
await endpoint.Send(command, pipe, cancellationToken).ConfigureAwait(false);
return(new ScheduledRecurringMessageHandle <T>(schedule, command.Destination, command.Payload));
}
public void Reschedule(RecurringSchedule schedule)
{
from = from.AddDays(DaysDistance(schedule));
duration = schedule.Duration;
}
