public async Task UpdateAsync(int id, string name, string code)
 {
     var entity = new HeatingZone(name, code);
     await heatingZoneRepository.UpdateAsync(id, entity);
 }
示例#2
0
        private async Task ConfigureQuartzJob(IScheduler scheduler, ScheduledEvent scheduledEvent, HeatingZone heatingZone, CancellationToken ct)
        {
            var job = JobBuilder.Create <SetTemperatureJob>()
                      .WithIdentity($"id-{scheduledEvent.Id}")
                      .UsingJobData(SetTemperatureJob.Key.ScheduledEventId, scheduledEvent.Id)
                      .UsingJobData(SetTemperatureJob.Key.HeatingZoneCode, heatingZone.Code)
                      .UsingJobData(SetTemperatureJob.Key.HeatingZoneName, heatingZone.Name)
                      .UsingJobData(SetTemperatureJob.Key.Temperature, scheduledEvent.Temperature)
                      .Build();

            var startDate          = GetStartDateTime(scheduledEvent);
            var startDateTimeLocal = startDate.Add(scheduledEvent.Time);
            var startDateTimeUtc   = startDateTimeLocal.ToUniversalTime();

            var triggerBuilder = TriggerBuilder.Create();

            triggerBuilder = triggerBuilder.StartAt(new DateTimeOffset(startDateTimeUtc));

            var logMessage = $"Event ID {scheduledEvent.Id} scheduled to {startDateTimeLocal} (UTC {startDateTimeUtc})";

            switch (scheduledEvent.Mode)
            {
            case ScheduleMode.RepeatDaily:
            {
                var oneDayInHours = 24;
                triggerBuilder = triggerBuilder
                                 .WithSimpleSchedule(builder => builder
                                                     .WithMisfireHandlingInstructionNextWithExistingCount()
                                                     .WithIntervalInHours(oneDayInHours)
                                                     .RepeatForever());

                logMessage += $" with interval in {oneDayInHours} hours";
                break;
            }

            case ScheduleMode.OneTimeOnly:
                triggerBuilder = triggerBuilder
                                 .WithSimpleSchedule(builder => builder
                                                     .WithMisfireHandlingInstructionNextWithExistingCount());
                logMessage += " as one time only event";
                break;

            default:
                logger.LogError($"Event ID {scheduledEvent.Id} - unknown {nameof(ScheduleMode)}: {scheduledEvent.Mode}.");
                return;
            }

            if (scheduledEvent.ValidTo is not null)
            {
                var endDate          = scheduledEvent.ValidTo.Value.Date;
                var endDateTimeLocal = endDate.Add(scheduledEvent.Time);
                var endDateTimeUtc   = endDateTimeLocal.ToUniversalTime();
                triggerBuilder.EndAt(new DateTimeOffset(endDateTimeUtc));

                logMessage += $". Valid to {endDateTimeLocal} (UTC {endDateTimeUtc})";
            }

            var trigger = triggerBuilder.Build();

            await scheduler.ScheduleJob(job, trigger, ct);

            logger.LogInformation(logMessage + ".");
        }
 public async Task CreateAsync(string name, string code)
 {
     var entity = new HeatingZone(name, code);
     await heatingZoneRepository.CreateAsync(entity);
 }