add schedule exemptions to form

awx/ui/src/components/Schedule/shared/ScheduleFormFields.js

@@ -3,6 +3,7 @@ import { useField } from 'formik';
 import { FormGroup, Title } from '@patternfly/react-core';
 import { t } from '@lingui/macro';
 import styled from 'styled-components';
+import 'styled-components/macro';
 import FormField from 'components/FormField';
 import { required } from 'util/validators';
 import { useConfig } from 'contexts/Config';
@@ -53,11 +54,11 @@ export default function ScheduleFormFields({
   }
   const config = useConfig();
 
-  // const [exceptionFrequency, exceptionFrequencyMeta, exceptionFrequencyHelper] =
+  const [exceptionFrequency, exceptionFrequencyMeta, exceptionFrequencyHelper] =
-  //   useField({
+    useField({
-  //     name: 'exceptionFrequency',
+      name: 'exceptionFrequency',
-  //     validate: required(t`Select a value for this field`),
+      validate: required(t`Select a value for this field`),
-  //   });
+    });
 
   const updateFrequency = (setFrequency) => (values) => {
     setFrequency(values.sort(sortFrequencies));
@@ -151,34 +152,40 @@ export default function ScheduleFormFields({
               />
             </FormColumnLayout>
           ))}
-          {/* <Title size="md" headingLevel="h4">{t`Exceptions`}</Title>
+          <Title
-          <FormGroup
+            size="md"
-            name="exceptions"
+            headingLevel="h4"
-            fieldId="exception-frequency"
+            css="margin-top: var(--pf-c-card--child--PaddingRight)"
-            helperTextInvalid={exceptionFrequencyMeta.error}
+          >{t`Exceptions`}</Title>
-            validated={
+          <FormColumnLayout stacked>
-              !exceptionFrequencyMeta.touched || !exceptionFrequencyMeta.error
+            <FormGroup
-                ? 'default'
+              name="exceptions"
-                : 'error'
+              fieldId="exception-frequency"
-            }
+              helperTextInvalid={exceptionFrequencyMeta.error}
-            label={t`Add exceptions`}
+              validated={
-          >
+                !exceptionFrequencyMeta.touched || !exceptionFrequencyMeta.error
-            <FrequencySelect
+                  ? 'default'
-              variant={SelectVariant.checkbox}
+                  : 'error'
-              onChange={exceptionFrequencyHelper.setValue}
+              }
-              value={exceptionFrequency.value}
+              label={t`Add exceptions`}
-              placeholderText={t`None`}
-              onBlur={exceptionFrequencyHelper.setTouched}
             >
-              <SelectClearOption value="none">{t`None`}</SelectClearOption>
+              <FrequencySelect
-              <SelectOption value="minute">{t`Minute`}</SelectOption>
+                id="exception-frequency"
-              <SelectOption value="hour">{t`Hour`}</SelectOption>
+                onChange={exceptionFrequencyHelper.setValue}
-              <SelectOption value="day">{t`Day`}</SelectOption>
+                value={exceptionFrequency.value}
-              <SelectOption value="week">{t`Week`}</SelectOption>
+                placeholderText={t`None`}
-              <SelectOption value="month">{t`Month`}</SelectOption>
+                onBlur={exceptionFrequencyHelper.setTouched}
-              <SelectOption value="year">{t`Year`}</SelectOption>
+              >
-            </FrequencySelect>
+                <SelectClearOption value="none">{t`None`}</SelectClearOption>
-          </FormGroup>
+                <SelectOption value="minute">{t`Minute`}</SelectOption>
+                <SelectOption value="hour">{t`Hour`}</SelectOption>
+                <SelectOption value="day">{t`Day`}</SelectOption>
+                <SelectOption value="week">{t`Week`}</SelectOption>
+                <SelectOption value="month">{t`Month`}</SelectOption>
+                <SelectOption value="year">{t`Year`}</SelectOption>
+              </FrequencySelect>
+            </FormGroup>
+          </FormColumnLayout>
           {exceptionFrequency.value.map((val) => (
             <FormColumnLayout key={val} stacked>
               <FrequencyDetailSubform
@@ -186,7 +193,7 @@ export default function ScheduleFormFields({
                 prefix={`exceptionOptions.${val}`}
               />
             </FormColumnLayout>
-          ))} */}
+          ))}
         </SubFormLayout>
       ) : null}
     </>

awx/ui/src/components/Schedule/shared/buildRuleSet.js

@@ -39,7 +39,19 @@ export default function buildRuleSet(values) {
     set.rrule(new RRule(rule));
   });
 
-  // TODO: exclusions
+  frequencies.forEach((frequency) => {
+    if (!values.exceptionFrequency?.includes(frequency)) {
+      return;
+    }
+    const rule = buildRuleObj({
+      startDate: values.startDate,
+      startTime: values.startTime,
+      timezone: values.timezone,
+      frequency,
+      ...values.exceptionOptions[frequency],
+    });
+    set.exrule(new RRule(rule));
+  });
 
   return set;
 }

awx/ui/src/components/Schedule/shared/buildRuleSet.test.js

@@ -243,4 +243,257 @@ RRULE:INTERVAL=1;FREQ=MONTHLY;BYSETPOS=2;BYDAY=MO;UNTIL=20260602T170000Z`);
     expect(ruleSet.toString()).toEqual(`DTSTART:20220613T123000Z
 RRULE:INTERVAL=1;COUNT=1;FREQ=MINUTELY`);
   });
+
+  test('should build minutely exception', () => {
+    const values = {
+      startDate: '2022-06-13',
+      startTime: '12:30 PM',
+      frequency: ['minute'],
+      frequencyOptions: {
+        minute: {
+          interval: 1,
+          end: 'never',
+        },
+      },
+      exceptionFrequency: ['minute'],
+      exceptionOptions: {
+        minute: {
+          interval: 3,
+          end: 'never',
+        },
+      },
+    };
+
+    const ruleSet = buildRuleSet(values);
+    expect(ruleSet.toString()).toEqual(
+      [
+        'DTSTART:20220613T123000Z',
+        'RRULE:INTERVAL=1;FREQ=MINUTELY',
+        'EXRULE:INTERVAL=3;FREQ=MINUTELY',
+      ].join('\n')
+    );
+  });
+
+  test('should build hourly exception', () => {
+    const values = {
+      startDate: '2022-06-13',
+      startTime: '12:30 PM',
+      frequency: ['minute'],
+      frequencyOptions: {
+        minute: {
+          interval: 1,
+          end: 'never',
+        },
+      },
+      exceptionFrequency: ['hour'],
+      exceptionOptions: {
+        hour: {
+          interval: 3,
+          end: 'never',
+        },
+      },
+    };
+
+    const ruleSet = buildRuleSet(values);
+    expect(ruleSet.toString()).toEqual(
+      [
+        'DTSTART:20220613T123000Z',
+        'RRULE:INTERVAL=1;FREQ=MINUTELY',
+        'EXRULE:INTERVAL=3;FREQ=HOURLY',
+      ].join('\n')
+    );
+  });
+
+  test('should build daily exception', () => {
+    const values = {
+      startDate: '2022-06-13',
+      startTime: '12:30 PM',
+      frequency: ['minute'],
+      frequencyOptions: {
+        minute: {
+          interval: 1,
+          end: 'never',
+        },
+      },
+      exceptionFrequency: ['day'],
+      exceptionOptions: {
+        day: {
+          interval: 3,
+          end: 'never',
+        },
+      },
+    };
+
+    const ruleSet = buildRuleSet(values);
+    expect(ruleSet.toString()).toEqual(
+      [
+        'DTSTART:20220613T123000Z',
+        'RRULE:INTERVAL=1;FREQ=MINUTELY',
+        'EXRULE:INTERVAL=3;FREQ=DAILY',
+      ].join('\n')
+    );
+  });
+
+  test('should build weekly exception', () => {
+    const values = {
+      startDate: '2022-06-13',
+      startTime: '12:30 PM',
+      frequency: ['minute'],
+      frequencyOptions: {
+        minute: {
+          interval: 1,
+          end: 'never',
+        },
+      },
+      exceptionFrequency: ['week'],
+      exceptionOptions: {
+        week: {
+          interval: 3,
+          end: 'never',
+          daysOfWeek: [RRule.SU],
+        },
+      },
+    };
+
+    const ruleSet = buildRuleSet(values);
+    expect(ruleSet.toString()).toEqual(
+      [
+        'DTSTART:20220613T123000Z',
+        'RRULE:INTERVAL=1;FREQ=MINUTELY',
+        'EXRULE:INTERVAL=3;FREQ=WEEKLY;BYDAY=SU',
+      ].join('\n')
+    );
+  });
+
+  test('should build monthly exception by day', () => {
+    const values = {
+      startDate: '2022-06-13',
+      startTime: '12:30 PM',
+      frequency: ['minute'],
+      frequencyOptions: {
+        minute: {
+          interval: 1,
+          end: 'never',
+        },
+      },
+      exceptionFrequency: ['month'],
+      exceptionOptions: {
+        month: {
+          interval: 3,
+          end: 'never',
+          runOn: 'day',
+          runOnDayNumber: 15,
+        },
+      },
+    };
+
+    const ruleSet = buildRuleSet(values);
+    expect(ruleSet.toString()).toEqual(
+      [
+        'DTSTART:20220613T123000Z',
+        'RRULE:INTERVAL=1;FREQ=MINUTELY',
+        'EXRULE:INTERVAL=3;FREQ=MONTHLY;BYMONTHDAY=15',
+      ].join('\n')
+    );
+  });
+
+  test('should build monthly exception by weekday', () => {
+    const values = {
+      startDate: '2022-06-13',
+      startTime: '12:30 PM',
+      frequency: ['minute'],
+      frequencyOptions: {
+        minute: {
+          interval: 1,
+          end: 'never',
+        },
+      },
+      exceptionFrequency: ['month'],
+      exceptionOptions: {
+        month: {
+          interval: 3,
+          end: 'never',
+          runOn: 'the',
+          runOnTheOccurrence: 2,
+          runOnTheDay: 'monday',
+        },
+      },
+    };
+
+    const ruleSet = buildRuleSet(values);
+    expect(ruleSet.toString()).toEqual(
+      [
+        'DTSTART:20220613T123000Z',
+        'RRULE:INTERVAL=1;FREQ=MINUTELY',
+        'EXRULE:INTERVAL=3;FREQ=MONTHLY;BYSETPOS=2;BYDAY=MO',
+      ].join('\n')
+    );
+  });
+
+  test('should build annual exception by day', () => {
+    const values = {
+      startDate: '2022-06-13',
+      startTime: '12:30 PM',
+      frequency: ['minute'],
+      frequencyOptions: {
+        minute: {
+          interval: 1,
+          end: 'never',
+        },
+      },
+      exceptionFrequency: ['year'],
+      exceptionOptions: {
+        year: {
+          interval: 1,
+          end: 'never',
+          runOn: 'day',
+          runOnDayMonth: 3,
+          runOnDayNumber: 15,
+        },
+      },
+    };
+
+    const ruleSet = buildRuleSet(values);
+    expect(ruleSet.toString()).toEqual(
+      [
+        'DTSTART:20220613T123000Z',
+        'RRULE:INTERVAL=1;FREQ=MINUTELY',
+        'EXRULE:INTERVAL=1;FREQ=YEARLY;BYMONTH=3;BYMONTHDAY=15',
+      ].join('\n')
+    );
+  });
+
+  test('should build annual exception by weekday', () => {
+    const values = {
+      startDate: '2022-06-13',
+      startTime: '12:30 PM',
+      frequency: ['minute'],
+      frequencyOptions: {
+        minute: {
+          interval: 1,
+          end: 'never',
+        },
+      },
+      exceptionFrequency: ['year'],
+      exceptionOptions: {
+        year: {
+          interval: 1,
+          end: 'never',
+          runOn: 'the',
+          runOnTheOccurrence: 4,
+          runOnTheDay: 'monday',
+          runOnTheMonth: 6,
+        },
+      },
+    };
+
+    const ruleSet = buildRuleSet(values);
+    expect(ruleSet.toString()).toEqual(
+      [
+        'DTSTART:20220613T123000Z',
+        'RRULE:INTERVAL=1;FREQ=MINUTELY',
+        'EXRULE:INTERVAL=1;FREQ=YEARLY;BYSETPOS=4;BYDAY=MO;BYMONTH=6',
+      ].join('\n')
+    );
+  });
 });

awx/ui/src/components/Schedule/shared/parseRuleObj.js

@@ -32,6 +32,9 @@ export default function parseRuleObj(schedule) {
       case 'RRULE':
         values = parseRrule(ruleString, schedule, values);
         break;
+      case 'EXRULE':
+        values = parseExRule(ruleString, schedule, values);
+        break;
       default:
         throw new UnsupportedRRuleError(`Unsupported rrule type: ${type}`);
     }
@@ -79,6 +82,54 @@ const frequencyTypes = {
 };
 
 function parseRrule(rruleString, schedule, values) {
+  const { frequency, options } = parseRule(
+    rruleString,
+    schedule,
+    values.exceptionFrequency
+  );
+
+  if (values.frequencyOptions[frequency]) {
+    throw new UnsupportedRRuleError(
+      'Duplicate exception frequency types not supported'
+    );
+  }
+
+  return {
+    ...values,
+    frequency: [...values.frequency, frequency].sort(sortFrequencies),
+    frequencyOptions: {
+      ...values.frequencyOptions,
+      [frequency]: options,
+    },
+  };
+}
+
+function parseExRule(exruleString, schedule, values) {
+  const { frequency, options } = parseRule(
+    exruleString,
+    schedule,
+    values.exceptionFrequency
+  );
+
+  if (values.exceptionOptions[frequency]) {
+    throw new UnsupportedRRuleError(
+      'Duplicate exception frequency types not supported'
+    );
+  }
+
+  return {
+    ...values,
+    exceptionFrequency: [...values.exceptionFrequency, frequency].sort(
+      sortFrequencies
+    ),
+    exceptionOptions: {
+      ...values.exceptionOptions,
+      [frequency]: options,
+    },
+  };
+}
+
+function parseRule(ruleString, schedule, frequencies) {
   const {
     origOptions: {
       bymonth,
@@ -90,7 +141,7 @@ function parseRrule(rruleString, schedule, values) {
       interval,
       until,
     },
-  } = RRule.fromString(rruleString);
+  } = RRule.fromString(ruleString);
 
   const now = DateTime.now();
   const closestQuarterHour = DateTime.fromMillis(
@@ -127,7 +178,7 @@ function parseRrule(rruleString, schedule, values) {
     throw new Error(`Unexpected rrule frequency: ${freq}`);
   }
   const frequency = frequencyTypes[freq];
-  if (values.frequency.includes(frequency)) {
+  if (frequencies.includes(frequency)) {
     throw new Error(`Duplicate frequency types not supported (${frequency})`);
   }
 
@@ -171,17 +222,9 @@ function parseRrule(rruleString, schedule, values) {
     }
   }
 
-  if (values.frequencyOptions.frequency) {
-    throw new UnsupportedRRuleError('Duplicate frequency types not supported');
-  }
-
   return {
-    ...values,
+    frequency,
-    frequency: [...values.frequency, frequency].sort(sortFrequencies),
+    options,
-    frequencyOptions: {
-      ...values.frequencyOptions,
-      [frequency]: options,
-    },
   };
 }
 

awx/ui/src/components/Schedule/shared/parseRuleObj.test.js

@@ -241,4 +241,51 @@ RRULE:INTERVAL=1;FREQ=MONTHLY;BYSETPOS=2;BYDAY=MO;UNTIL=20260602T170000Z`;
 
     expect(parsed).toEqual(values);
   });
+
+  test('should parse exemptions', () => {
+    const schedule = {
+      rrule: [
+        'DTSTART;TZID=US/Eastern:20220608T123000',
+        'RRULE:INTERVAL=1;FREQ=WEEKLY;BYDAY=MO',
+        'EXRULE:INTERVAL=1;FREQ=MONTHLY;BYSETPOS=1;BYDAY=MO',
+      ].join(' '),
+      dtstart: '2022-06-13T16:30:00Z',
+      timezone: 'US/Eastern',
+      until: '',
+      dtend: null,
+    };
+
+    const parsed = parseRuleObj(schedule);
+
+    expect(parsed).toEqual({
+      startDate: '2022-06-13',
+      startTime: '12:30 PM',
+      timezone: 'US/Eastern',
+      frequency: ['week'],
+      frequencyOptions: {
+        week: {
+          interval: 1,
+          end: 'never',
+          occurrences: 1,
+          endDate: '2022-06-02',
+          endTime: '1:00 PM',
+          daysOfWeek: [RRule.MO],
+        },
+      },
+      exceptionFrequency: ['month'],
+      exceptionOptions: {
+        month: {
+          interval: 1,
+          end: 'never',
+          endDate: '2022-06-02',
+          endTime: '1:00 PM',
+          occurrences: 1,
+          runOn: 'the',
+          runOnDayNumber: 1,
+          runOnTheOccurrence: 1,
+          runOnTheDay: 'monday',
+        },
+      },
+    });
+  });
 });