Merge pull request #677 from UrekD/master

Extend repeat schedule functionality #676

Author: bugy

src/model/external_model.py

@@ -129,6 +129,8 @@ def parse_external_schedule(external_schedule):
     return {
         'repeatable': external_schedule.get('repeatable'),
         'start_datetime': external_schedule.get('startDatetime'),
+        'end_option': external_schedule.get('endOption'),
+        'end_arg': external_schedule.get('endArg'),
         'repeat_unit': external_schedule.get('repeatUnit'),
         'repeat_period': external_schedule.get('repeatPeriod'),
         'weekdays': external_schedule.get('weekDays')

src/scheduling/schedule_config.py

@@ -7,12 +7,11 @@
 ALLOWED_WEEKDAYS = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
 
 
-def _read_start_datetime(incoming_schedule_config):
-    start_datetime = model_helper.read_datetime_from_config('start_datetime', incoming_schedule_config)
-    if start_datetime is None:
-        raise InvalidScheduleException('start_datetime is required')
-    return start_datetime
-
+def _read_datetime(incoming_schedule_config, key):
+    datetime_value = model_helper.read_datetime_from_config(key, incoming_schedule_config)
+    if datetime_value is None:
+        raise InvalidScheduleException(f'{key} is required')
+    return datetime_value
 
 def _read_repeat_unit(incoming_schedule_config):
     repeat_unit = incoming_schedule_config.get('repeat_unit')
@@ -32,6 +31,27 @@ def _read_repeat_period(incoming_schedule_config):
     return period
 
 
+def _read_end_arg_int(incoming_schedule_config):
+    end_arg = model_helper.read_int_from_config('end_arg', incoming_schedule_config)
+    if end_arg is None:
+        raise InvalidScheduleException('end_arg is required for repeatable schedule')
+    elif end_arg <= 0:
+        raise InvalidScheduleException('end_arg should be > 0')
+    return end_arg
+
+
+def _read_end_args(incoming_schedule_config):
+    end_option = incoming_schedule_config.get('end_option')
+    if end_option == 'end_datetime':
+        end_arg = _read_datetime(incoming_schedule_config, 'end_arg')
+        return end_option,end_arg
+    elif end_option == 'max_executions':
+        end_arg = _read_end_arg_int(incoming_schedule_config)
+        return end_option,end_arg
+    else:
+        return end_option,None
+
+
 def read_repeatable_flag(incoming_schedule_config):
     repeatable = model_helper.read_bool_from_config('repeatable', incoming_schedule_config)
     if repeatable is None:
@@ -52,10 +72,15 @@ def read_weekdays(incoming_schedule_config):
 
 def read_schedule_config(incoming_schedule_config):
     repeatable = read_repeatable_flag(incoming_schedule_config)
-    start_datetime = _read_start_datetime(incoming_schedule_config)
+    start_datetime = _read_datetime(incoming_schedule_config, 'start_datetime')
 
     prepared_schedule_config = ScheduleConfig(repeatable, start_datetime)
     if repeatable:
+
+        prepared_schedule_config.executions_count = model_helper.read_int_from_config('executions_count', incoming_schedule_config, default=0)
+
+        prepared_schedule_config.end_option, prepared_schedule_config.end_arg = _read_end_args(incoming_schedule_config)
+
         prepared_schedule_config.repeat_unit = _read_repeat_unit(incoming_schedule_config)
         prepared_schedule_config.repeat_period = _read_repeat_period(incoming_schedule_config)
 
@@ -70,6 +95,9 @@ class ScheduleConfig:
     def __init__(self, repeatable, start_datetime) -> None:
         self.repeatable = repeatable
         self.start_datetime = start_datetime  # type: datetime
+        self.end_option = None
+        self.end_arg = None
+        self.executions_count = None
         self.repeat_unit = None
         self.repeat_period = None
         self.weekdays = None
@@ -80,6 +108,16 @@ def as_serializable_dict(self):
             'start_datetime': date_utils.to_iso_string(self.start_datetime)
         }
 
+        if self.end_option == 'end_datetime':
+            result['end_option'] = self.end_option
+            result['end_arg'] = date_utils.to_iso_string(self.end_arg)
+        elif self.end_option == 'max_executions':
+            result['end_option'] = self.end_option
+            result['end_arg'] = self.end_arg
+
+        if self.repeatable:
+            result['executions_count'] = self.executions_count
+
         if self.repeat_unit is not None:
             result['repeat_unit'] = self.repeat_unit
 

src/scheduling/schedule_service.py

@@ -76,6 +76,13 @@ def create_job(self, script_name, parameter_values, incoming_schedule_config, us
         if not schedule_config.repeatable and date_utils.is_past(schedule_config.start_datetime):
             raise InvalidScheduleException('Start date should be in the future')
 
+        if schedule_config.end_option == 'end_datetime':
+            if schedule_config.start_datetime > schedule_config.end_arg:
+                raise InvalidScheduleException('End date should be after start date')
+
+        if schedule_config.end_option == 'max_executions' and schedule_config.end_arg <= 0:
+            raise InvalidScheduleException('Count should be greater than 0!')
+
         id = self._id_generator.next_id()
 
         normalized_values = {}
@@ -106,8 +113,16 @@ def schedule_job(self, job: SchedulingJob, job_path):
 
         if not schedule.repeatable and date_utils.is_past(schedule.start_datetime):
             return
-
+        
+        if schedule.end_option == 'max_executions' and schedule.end_arg <= schedule.executions_count:
+            return                
+        
         next_datetime = schedule.get_next_time()
+
+        if schedule.end_option == 'end_datetime':
+            if next_datetime > schedule.end_arg:
+                return
+        
         LOGGER.info(
             'Scheduling ' + job.get_log_name() + ' at ' + next_datetime.astimezone(tz=None).strftime('%H:%M, %d %B %Y'))
 
@@ -136,6 +151,12 @@ def cleanup():
                     self._execution_service.cleanup_execution(execution_id, user)
 
                 self._execution_service.add_finish_listener(cleanup, execution_id)
+
+            if job.schedule.repeatable:
+                job.schedule.executions_count += 1
+
+                self.save_job(job)
+
         except:
             LOGGER.exception('Failed to execute ' + job.get_log_name())
 

web-src/src/main-app/components/schedule/SchedulePanel.vue

@@ -41,6 +41,39 @@
                       label="Time" @error="checkErrors"/>
         </div>
 
+        <div>
+          <span class="schedule-repeat_col-1">End:</span>
+          <div class="schedule-type-panel">
+            <p class="schedule-type-field">
+              <label>
+                <input :checked="endOption === 'never'" class="with-gap" name="end-type" type="radio" @click="endOption = 'never'" />
+                <span>Never</span>
+              </label>
+            </p>
+            <p class="schedule-type-field">
+              <label>
+                <input :checked="endOption === 'maxExecuteCount'" class="with-gap" name="end-type" type="radio" @click="endOption = 'maxExecuteCount'" />
+                <span>Count</span>
+              </label>
+            </p>
+            <p class="schedule-type-field">
+              <label>
+                <input :checked="endOption === 'endDatetime'" class="with-gap" name="end-type" type="radio" @click="endOption = 'endDatetime'" />
+                <span>Date</span>
+              </label>
+            </p>
+          </div>
+          <br>
+          <div v-if="endOption === 'endDatetime'">
+            <span class="schedule-repeat_col-1">Ending</span>
+            <DatePicker v-model="endDate" :show-header-in-modal="!mobileView" class="inline repeat-start-date schedule-repeat_col-2" label="Date" />
+            <TimePicker v-model="endTime" class="inline repeat-start-time schedule-repeat_col-3" label="Time" @error="checkErrors" />
+          </div>
+          <div v-if="endOption === 'maxExecuteCount'">
+            <span class="schedule-repeat_col-1">Count</span>
+            <Textfield v-model="maxExecuteCount" :config="repeatPeriodField" class="inline repeat-period-field schedule-repeat_col-2" @error="checkErrors" />
+          </div>
+
         <div v-if="repeatTimeUnit === 'weeks'" class="repeat-weeks-panel">
           <div :class="{ error: weekdaysError }" class="repeat-weekday-panel">
             <ToggleDayButton v-for="day in weekDays"
@@ -62,6 +95,7 @@
                         :preloaderStyle="{ width: '20px', height: '20px' }"
                         title="Schedule"/>
     </div>
+    </div>
   </div>
 </template>
 
@@ -93,12 +127,19 @@ export default {
     const now = new Date();
     const currentDay = now.getDay();
 
+    const endDay = new Date(now);
+    endDay.setDate(now.getDate() + 1);
+
     return {
       oneTimeSchedule: true,
       startDate: now,
       startTime: now.toTimeString().substr(0, 5),
+      endOption: 'never',
+      endDate: endDay,
+      endTime: endDay.toTimeString().substr(0, 5),
       id: null,
       repeatPeriod: 1,
+      maxExecuteCount: 1,
       repeatTimeUnit: 'days',
       weekDays: [
         {'day': 'Monday', active: currentDay === 1},
@@ -135,15 +176,30 @@ export default {
 
     buildScheduleSetup() {
       const startDatetime = new Date(this.startDate);
-      const [hours, minutes] = this.startTime.split(':')
-      startDatetime.setHours(parseInt(hours), parseInt(minutes), 0, 0)
+      const [hours, minutes] = this.startTime.split(':');
+      startDatetime.setHours(parseInt(hours), parseInt(minutes), 0, 0);
+
+      let endOption = this.endOption;
+      let endArg = null;
+
+      if (this.endOption === 'maxExecuteCount') {
+        endArg = this.maxExecuteCount;
+        endOption = 'max_executions';
+      } else if (this.endOption === 'endDatetime') {
+        const endDatetime = new Date(this.endDate);
+        const [hoursEnd, minutesEnd] = this.endTime.split(':');
+        endDatetime.setHours(parseInt(hoursEnd), parseInt(minutesEnd), 0, 0);
+        endArg = endDatetime;
+        endOption = 'end_datetime';
+      }
 
-      const weekDays = this.weekDays.filter(day => day.active)
-          .map(day => day.day);
+      const weekDays = this.weekDays.filter(day => day.active).map(day => day.day);
 
       return {
         repeatable: !this.oneTimeSchedule,
         startDatetime: startDatetime,
+        endOption: endOption,
+        endArg: endArg,
         repeatUnit: this.repeatTimeUnit,
         repeatPeriod: this.repeatPeriod,
         weekDays: weekDays
@@ -206,7 +262,7 @@ export default {
   font-size: 16px;
   max-width: 320px;
   width: 100%;
-  height: 380px;
+  height: 480px;
   display: flex;
   flex-direction: column;
   justify-content: space-between;