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; }