CE-936 add post-actions on scheduledJobParams table, to reschedule jobs

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/scheduledjobs/ScheduledJobsMetaDataProvider.java

@@ -45,6 +45,7 @@ import com.kingsrook.qqq.backend.core.model.metadata.tables.ExposedJoin;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QFieldSection;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.Tier;
+import com.kingsrook.qqq.backend.core.model.scheduledjobs.customizers.ScheduledJobParameterTableCustomizer;
 import com.kingsrook.qqq.backend.core.model.scheduledjobs.customizers.ScheduledJobTableCustomizer;
 
 
@@ -205,6 +206,12 @@ public class ScheduledJobsMetaDataProvider
          .withSection(new QFieldSection("identity", new QIcon().withName("badge"), Tier.T1, List.of("id", "scheduledJobId", "key", "value")))
          .withSection(new QFieldSection("dates", new QIcon().withName("calendar_month"), Tier.T3, List.of("createDate", "modifyDate")));
 
+
+      QCodeReference customizerReference = new QCodeReference(ScheduledJobParameterTableCustomizer.class);
+      tableMetaData.withCustomizer(TableCustomizers.POST_INSERT_RECORD, customizerReference);
+      tableMetaData.withCustomizer(TableCustomizers.POST_UPDATE_RECORD, customizerReference);
+      tableMetaData.withCustomizer(TableCustomizers.POST_DELETE_RECORD, customizerReference);
+
       tableMetaData.withExposedJoin(new ExposedJoin()
          .withJoinTable(ScheduledJob.TABLE_NAME)
          .withJoinPath(List.of(JOB_PARAMETER_JOIN_NAME))

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/scheduledjobs/customizers/ScheduledJobParameterTableCustomizer.java

@@ -0,0 +1,215 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2024.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.model.scheduledjobs.customizers;
+
+
+import java.time.Instant;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import com.kingsrook.qqq.backend.core.actions.customizers.TableCustomizerInterface;
+import com.kingsrook.qqq.backend.core.actions.tables.UpdateAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
+import com.kingsrook.qqq.backend.core.model.actions.AbstractTableActionInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateOutput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.scheduledjobs.ScheduledJob;
+import com.kingsrook.qqq.backend.core.model.scheduledjobs.ScheduledJobParameter;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.ListingHash;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class ScheduledJobParameterTableCustomizer implements TableCustomizerInterface
+{
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public List<QRecord> postInsert(InsertInput insertInput, List<QRecord> records) throws QException
+   {
+      ///////////////////////////////////////////////////////////////////////////////////////
+      // if we're in this insert as a result of an insert (or update) on a different table //
+      // (e.g., under a manageAssociations call), then return with noop - assume that the  //
+      // parent table's customizer will do what needed to be done.                         //
+      ///////////////////////////////////////////////////////////////////////////////////////
+      if(!isThisAnActionDirectlyOnThisTable())
+      {
+         return (records);
+      }
+
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // else - this was an action directly on this table - so bump all of the parent records, to get them rescheduled //
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      bumpParentRecords(records, Optional.empty());
+
+      return (records);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private void bumpParentRecords(List<QRecord> records, Optional<List<QRecord>> oldRecordList) throws QException
+   {
+      try
+      {
+         ///////////////////////////////////////////////////////////////////////////////////////////
+         // (listing) hash up the records by scheduledJobId - we'll use this to have a set of the //
+         // job ids, and in case we need to add warnings to them later                            //
+         ///////////////////////////////////////////////////////////////////////////////////////////
+         ListingHash<Integer, QRecord> recordsByJobId = new ListingHash<>();
+         for(QRecord record : records)
+         {
+            recordsByJobId.add(record.getValueInteger("scheduledJobId"), record);
+         }
+
+         Set<Integer> scheduledJobIds = new HashSet<>(recordsByJobId.keySet());
+
+         ////////////////////////////////////////////////////////////////////////////////
+         // if we have an old record list (e.g., is an edit), add any job ids that are //
+         // in those too, e.g., in case moving a param from one job to another...      //
+         // note, we won't line these up for doing a proper warning on these...        //
+         ////////////////////////////////////////////////////////////////////////////////
+         if(oldRecordList.isPresent())
+         {
+            for(QRecord oldRecord : oldRecordList.get())
+            {
+               scheduledJobIds.add(oldRecord.getValueInteger("scheduledJobId"));
+            }
+         }
+
+         ////////////////////////////////////////////////////////////////////////////////////////////////////
+         // update the modify date on the scheduled jobs - to get their post-actions to run, to reschedule //
+         ////////////////////////////////////////////////////////////////////////////////////////////////////
+         UpdateInput updateInput = new UpdateInput();
+         updateInput.setTableName(ScheduledJob.TABLE_NAME);
+         updateInput.setRecords(scheduledJobIds.stream()
+            .map(id -> new QRecord().withValue("id", id).withValue("modifyDate", Instant.now()))
+            .toList());
+         UpdateOutput updateOutput = new UpdateAction().execute(updateInput);
+
+         ////////////////////////////////////////////////////////////////////////////////////////
+         // look for warnings on those jobs - and propagate them to the params we just stored. //
+         ////////////////////////////////////////////////////////////////////////////////////////
+         for(QRecord updatedScheduledJob : updateOutput.getRecords())
+         {
+            if(CollectionUtils.nullSafeHasContents(updatedScheduledJob.getWarnings()))
+            {
+               for(QRecord paramToWarn : CollectionUtils.nonNullList(recordsByJobId.get(updatedScheduledJob.getValueInteger("id"))))
+               {
+                  paramToWarn.setWarnings(updatedScheduledJob.getWarnings());
+               }
+            }
+         }
+      }
+      catch(Exception e)
+      {
+         LOG.warn("Error in scheduledJobParameter post-crud", e);
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public List<QRecord> postUpdate(UpdateInput updateInput, List<QRecord> records, Optional<List<QRecord>> oldRecordList) throws QException
+   {
+      /////////////////////////////////////////////////////////////////////////////
+      // if we're in this update as a result of an update on a different table   //
+      // (e.g., under a manageAssociations call), then return with noop - assume //
+      // that the parent table's customizer will do what needed to be done.      //
+      /////////////////////////////////////////////////////////////////////////////
+      if(!isThisAnActionDirectlyOnThisTable())
+      {
+         return (records);
+      }
+
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // else - this was an action directly on this table - so bump all of the parent records, to get them rescheduled //
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      bumpParentRecords(records, oldRecordList);
+
+      return (records);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public List<QRecord> postDelete(DeleteInput deleteInput, List<QRecord> records) throws QException
+   {
+      /////////////////////////////////////////////////////////////////////////////
+      // if we're in this update as a result of an update on a different table   //
+      // (e.g., under a manageAssociations call), then return with noop - assume //
+      // that the parent table's customizer will do what needed to be done.      //
+      /////////////////////////////////////////////////////////////////////////////
+      if(!isThisAnActionDirectlyOnThisTable())
+      {
+         return (records);
+      }
+
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // else - this was an action directly on this table - so bump all of the parent records, to get them rescheduled //
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      bumpParentRecords(records, Optional.empty());
+
+      return (records);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private static boolean isThisAnActionDirectlyOnThisTable()
+   {
+      Optional<AbstractActionInput> firstActionInStack = QContext.getFirstActionInStack();
+      if(firstActionInStack.isPresent())
+      {
+         if(firstActionInStack.get() instanceof AbstractTableActionInput tableActionInput)
+         {
+            if(!ScheduledJobParameter.TABLE_NAME.equals(tableActionInput.getTableName()))
+            {
+               return (false);
+            }
+         }
+      }
+      return (true);
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/scheduledjobs/customizers/ScheduledJobTableCustomizer.java

@@ -22,10 +22,12 @@
 package com.kingsrook.qqq.backend.core.model.scheduledjobs.customizers;
 
 
-import java.io.Serializable;
+import java.text.ParseException;
+import java.util.Collections;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Predicate;
@@ -47,6 +49,7 @@ import com.kingsrook.qqq.backend.core.model.statusmessages.QWarningMessage;
 import com.kingsrook.qqq.backend.core.scheduler.QScheduleManager;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
+import org.quartz.CronScheduleBuilder;
 import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
@@ -62,7 +65,7 @@ public class ScheduledJobTableCustomizer implements TableCustomizerInterface
    @Override
    public List<QRecord> preInsert(InsertInput insertInput, List<QRecord> records, boolean isPreview) throws QException
    {
-      validateConditionalFields(records);
+      validateConditionalFields(records, Collections.emptyMap());
       return (records);
    }
 
@@ -86,7 +89,9 @@ public class ScheduledJobTableCustomizer implements TableCustomizerInterface
    @Override
    public List<QRecord> preUpdate(UpdateInput updateInput, List<QRecord> records, boolean isPreview, Optional<List<QRecord>> oldRecordList) throws QException
    {
-      validateConditionalFields(records);
+      Map<Integer, QRecord> freshOldRecordsWithAssociationsMap = CollectionUtils.recordsToMap(freshlyQueryForRecordsWithAssociations(oldRecordList.get()), "id", Integer.class);
+
+      validateConditionalFields(records, freshOldRecordsWithAssociationsMap);
 
       if(isPreview || oldRecordList.isEmpty())
       {
@@ -96,8 +101,7 @@ public class ScheduledJobTableCustomizer implements TableCustomizerInterface
       ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       // refresh the old-records w/ versions that have associations - so we can use those in the post-update to property unschedule things //
       ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-      Map<Serializable, QRecord> freshOldRecordsWithAssociationsMap = CollectionUtils.recordsToMap(freshlyQueryForRecordsWithAssociations(oldRecordList.get()), "id");
+      ListIterator<QRecord> iterator = oldRecordList.get().listIterator();
-      ListIterator<QRecord>      iterator                           = oldRecordList.get().listIterator();
       while(iterator.hasNext())
       {
          QRecord record      = iterator.next();
@@ -116,20 +120,40 @@ public class ScheduledJobTableCustomizer implements TableCustomizerInterface
    /*******************************************************************************
     **
     *******************************************************************************/
-   private static void validateConditionalFields(List<QRecord> records)
+   private static void validateConditionalFields(List<QRecord> records, Map<Integer, QRecord> freshOldRecordsWithAssociationsMap)
    {
+      QRecord blankRecord = new QRecord();
       for(QRecord record : records)
       {
-         if(StringUtils.hasContent(record.getValueString("cronExpression")))
+         QRecord oldRecord = Objects.requireNonNullElse(freshOldRecordsWithAssociationsMap.get(record.getValueInteger("id")), blankRecord);
+         String cronExpression = record.getValues().containsKey("cronExpression") ? record.getValueString("cronExpression") : oldRecord.getValueString("cronExpression");
+         String cronTimeZoneId = record.getValues().containsKey("cronTimeZoneId") ? record.getValueString("cronTimeZoneId") : oldRecord.getValueString("cronTimeZoneId");
+         String repeatSeconds = record.getValues().containsKey("repeatSeconds") ? record.getValueString("repeatSeconds") : oldRecord.getValueString("repeatSeconds");
+
+         if(StringUtils.hasContent(cronExpression))
          {
-            if(!StringUtils.hasContent(record.getValueString("cronTimeZoneId")))
+            if(StringUtils.hasContent(repeatSeconds))
             {
-               record.addError(new BadInputStatusMessage("If a Cron Expression is given, then a Cron Time Zone Id is required."));
+               record.addError(new BadInputStatusMessage("Cron Expression and Repeat Seconds may not both be given."));
+            }
+            
+            try
+            {
+               CronScheduleBuilder.cronScheduleNonvalidatedExpression(cronExpression);
+            }
+            catch(ParseException e)
+            {
+               record.addError(new BadInputStatusMessage("Cron Expression [" + cronExpression + "] is not valid: " + e.getMessage()));
+            }
+
+            if(!StringUtils.hasContent(cronTimeZoneId))
+            {
+               record.addError(new BadInputStatusMessage("If a Cron Expression is given, then a Cron Time Zone is required."));
             }
          }
          else
          {
-            if(!StringUtils.hasContent(record.getValueString("repeatSeconds")))
+            if(!StringUtils.hasContent(repeatSeconds))
             {
                record.addError(new BadInputStatusMessage("Either Cron Expression or Repeat Seconds must be given."));
             }

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/model/scheduledjobs/customizers/ScheduledJobTableCustomizerTest.java

@@ -0,0 +1,383 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2024.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.model.scheduledjobs.customizers;
+
+
+import java.time.Instant;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import com.kingsrook.qqq.backend.core.BaseTest;
+import com.kingsrook.qqq.backend.core.actions.tables.DeleteAction;
+import com.kingsrook.qqq.backend.core.actions.tables.InsertAction;
+import com.kingsrook.qqq.backend.core.actions.tables.UpdateAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateOutput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+import com.kingsrook.qqq.backend.core.model.scheduledjobs.ScheduledJob;
+import com.kingsrook.qqq.backend.core.model.scheduledjobs.ScheduledJobParameter;
+import com.kingsrook.qqq.backend.core.model.scheduledjobs.ScheduledJobType;
+import com.kingsrook.qqq.backend.core.model.scheduledjobs.ScheduledJobsMetaDataProvider;
+import com.kingsrook.qqq.backend.core.model.session.QSession;
+import com.kingsrook.qqq.backend.core.scheduler.QScheduleManager;
+import com.kingsrook.qqq.backend.core.scheduler.quartz.QuartzJobAndTriggerWrapper;
+import com.kingsrook.qqq.backend.core.scheduler.quartz.QuartzTestUtils;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.TestUtils;
+import com.kingsrook.qqq.backend.core.utils.lambdas.UnsafeFunction;
+import org.assertj.core.api.AbstractStringAssert;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.quartz.CronTrigger;
+import org.quartz.SchedulerException;
+import org.quartz.SimpleTrigger;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+/*******************************************************************************
+ ** Unit test for ScheduledJobTableCustomizer 
+ *******************************************************************************/
+class ScheduledJobTableCustomizerTest extends BaseTest
+{
+   private static final String GOOD_CRON   = "0 * * * * ?";
+   private static final String GOOD_CRON_2 = "* * * * * ?";
+   private static final String BAD_CRON    = "* * * * * *";
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @BeforeEach
+   void beforeEach() throws QException
+   {
+      QInstance qInstance = QContext.getQInstance();
+      QuartzTestUtils.setupInstanceForQuartzTests();
+
+      QSession         qSession         = QContext.getQSession();
+      QScheduleManager qScheduleManager = QScheduleManager.initInstance(qInstance, () -> qSession);
+      qScheduleManager.start();
+
+      new ScheduledJobsMetaDataProvider().defineAll(qInstance, TestUtils.MEMORY_BACKEND_NAME, null);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @AfterEach
+   void afterEach()
+   {
+      QuartzTestUtils.afterEach();
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testPreInsertAssertValidationErrors() throws QException
+   {
+      UnsafeFunction<Consumer<ScheduledJob>, QRecord, QException> tryToInsert = consumer ->
+      {
+         ScheduledJob scheduledJob = new ScheduledJob()
+            .withLabel("Test")
+            .withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
+            .withType(ScheduledJobType.PROCESS.name())
+            .withIsActive(true);
+         consumer.accept(scheduledJob);
+         InsertOutput insertOutput = new InsertAction().execute(new InsertInput(ScheduledJob.TABLE_NAME).withRecordEntity(scheduledJob));
+         return (insertOutput.getRecords().get(0));
+      };
+
+      /////////////////////////////////////////////////////////
+      // lambdas to run a test and assert about no of errors //
+      /////////////////////////////////////////////////////////
+      Function<QRecord, AbstractStringAssert<?>> assertOneErrorExtractingMessage = qRecord -> assertThat(qRecord.getErrors()).hasSize(1).first().extracting("message").asString();
+      Consumer<QRecord>                          assertNoErrors                  = qRecord -> assertThat(qRecord.getErrors()).hasSize(0);
+
+      assertOneErrorExtractingMessage.apply(tryToInsert.apply(sj -> sj.setId(null)))
+         .contains("Either Cron Expression or Repeat Seconds must be given");
+
+      assertOneErrorExtractingMessage.apply(tryToInsert.apply(sj -> sj.withRepeatSeconds(1).withCronExpression(GOOD_CRON).withCronTimeZoneId("UTC")))
+         .contains("Cron Expression and Repeat Seconds may not both be given");
+
+      assertOneErrorExtractingMessage.apply(tryToInsert.apply(sj -> sj.withRepeatSeconds(null).withCronExpression(GOOD_CRON)))
+         .contains("If a Cron Expression is given, then a Cron Time Zone is required");
+
+      assertOneErrorExtractingMessage.apply(tryToInsert.apply(sj -> sj.withRepeatSeconds(null).withCronExpression(BAD_CRON).withCronTimeZoneId("UTC")))
+         .contains("Support for specifying both a day-of-week AND a day-of-month parameter is not implemented");
+
+      ///////////////////
+      // success cases //
+      ///////////////////
+      assertNoErrors.accept(tryToInsert.apply(sj -> sj.withCronExpression(GOOD_CRON).withCronTimeZoneId("UTC")));
+      assertNoErrors.accept(tryToInsert.apply(sj -> sj.withRepeatSeconds(1)));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testPostInsertActionSchedulesJob() throws QException, SchedulerException
+   {
+      List<QuartzJobAndTriggerWrapper> wrappers = QuartzTestUtils.queryQuartz();
+      assertEquals(0, wrappers.size());
+
+      InsertOutput insertOutput = new InsertAction().execute(new InsertInput(ScheduledJob.TABLE_NAME).withRecordEntity(new ScheduledJob()
+         .withLabel("Test")
+         .withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
+         .withType(ScheduledJobType.PROCESS.name())
+         .withIsActive(true)
+         .withRepeatSeconds(1)
+         .withJobParameters(List.of(
+            new ScheduledJobParameter().withKey("processName").withValue(TestUtils.PROCESS_NAME_BASEPULL)))));
+
+      assertTrue(CollectionUtils.nullSafeIsEmpty(insertOutput.getRecords().get(0).getErrors()));
+      assertTrue(CollectionUtils.nullSafeIsEmpty(insertOutput.getRecords().get(0).getWarnings()));
+
+      wrappers = QuartzTestUtils.queryQuartz();
+      assertEquals(1, wrappers.size());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testPostInsertActionIssuesWarnings() throws QException, SchedulerException
+   {
+      List<QuartzJobAndTriggerWrapper> wrappers = QuartzTestUtils.queryQuartz();
+      assertEquals(0, wrappers.size());
+
+      InsertOutput insertOutput = new InsertAction().execute(new InsertInput(ScheduledJob.TABLE_NAME).withRecordEntity(new ScheduledJob()
+         .withLabel("Test")
+         .withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
+         .withType(ScheduledJobType.PROCESS.name())
+         .withIsActive(true)
+         .withRepeatSeconds(1)
+         .withJobParameters(List.of(
+            new ScheduledJobParameter().withKey("processName").withValue("notAProcess")))));
+
+      assertTrue(CollectionUtils.nullSafeIsEmpty(insertOutput.getRecords().get(0).getErrors()));
+      assertThat(insertOutput.getRecords().get(0).getWarnings())
+         .hasSize(1).first().extracting("message").asString()
+         .contains("Error scheduling job: Unrecognized processName");
+
+      wrappers = QuartzTestUtils.queryQuartz();
+      assertEquals(0, wrappers.size());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testPreUpdateAssertValidationErrors() throws QException
+   {
+      new InsertAction().execute(new InsertInput(ScheduledJob.TABLE_NAME).withRecordEntity(new ScheduledJob()
+         .withLabel("Test")
+         .withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
+         .withType(ScheduledJobType.PROCESS.name())
+         .withIsActive(true)
+         .withRepeatSeconds(1)));
+
+      UnsafeFunction<Consumer<QRecord>, QRecord, QException> tryToUpdate = consumer ->
+      {
+         QRecord record = new QRecord().withValue("id", 1);
+         consumer.accept(record);
+         UpdateOutput updateOutput = new UpdateAction().execute(new UpdateInput(ScheduledJob.TABLE_NAME).withRecord(record));
+         return (updateOutput.getRecords().get(0));
+      };
+
+      /////////////////////////////////////////////////////////
+      // lambdas to run a test and assert about no of errors //
+      /////////////////////////////////////////////////////////
+      Function<QRecord, AbstractStringAssert<?>> assertOneErrorExtractingMessage = qRecord -> assertThat(qRecord.getErrors()).hasSize(1).first().extracting("message").asString();
+      Consumer<QRecord>                          assertNoErrors                  = qRecord -> assertThat(qRecord.getErrors()).hasSize(0);
+
+      assertOneErrorExtractingMessage.apply(tryToUpdate.apply(r -> r.withValue("repeatSeconds", null)))
+         .contains("Either Cron Expression or Repeat Seconds must be given");
+
+      assertOneErrorExtractingMessage.apply(tryToUpdate.apply(r -> r.withValue("cronExpression", GOOD_CRON).withValue("cronTimeZoneId", "UTC")))
+         .contains("Cron Expression and Repeat Seconds may not both be given");
+
+      assertOneErrorExtractingMessage.apply(tryToUpdate.apply(r -> r.withValue("repeatSeconds", null).withValue("cronExpression", GOOD_CRON)))
+         .contains("If a Cron Expression is given, then a Cron Time Zone is required");
+
+      assertOneErrorExtractingMessage.apply(tryToUpdate.apply(r -> r.withValue("repeatSeconds", null).withValue("cronExpression", BAD_CRON).withValue("cronTimeZoneId", "UTC")))
+         .contains("Support for specifying both a day-of-week AND a day-of-month parameter is not implemented");
+
+      ///////////////////
+      // success cases //
+      ///////////////////
+      assertNoErrors.accept(tryToUpdate.apply(r -> r.withValue("modifyDate", Instant.now())));
+      assertNoErrors.accept(tryToUpdate.apply(r -> r.withValue("repeatSeconds", null).withValue("cronExpression", GOOD_CRON).withValue("cronTimeZoneId", "UTC")));
+      assertNoErrors.accept(tryToUpdate.apply(r -> r.withValue("repeatSeconds", null).withValue("cronExpression", GOOD_CRON_2).withValue("cronTimeZoneId", "UTC")));
+      assertNoErrors.accept(tryToUpdate.apply(r -> r.withValue("repeatSeconds", null).withValue("cronExpression", GOOD_CRON).withValue("cronTimeZoneId", "America/Chicago")));
+      assertNoErrors.accept(tryToUpdate.apply(r -> r.withValue("repeatSeconds", 1).withValue("cronExpression", null).withValue("cronTimeZoneId", null)));
+      assertNoErrors.accept(tryToUpdate.apply(r -> r.withValue("repeatSeconds", 2)));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testPostUpdateActionReSchedulesJob() throws QException, SchedulerException
+   {
+      List<QuartzJobAndTriggerWrapper> wrappers = QuartzTestUtils.queryQuartz();
+      assertEquals(0, wrappers.size());
+
+      //////////////////////////////////////////////////
+      // do an insert - this will originally schedule //
+      //////////////////////////////////////////////////
+      new InsertAction().execute(new InsertInput(ScheduledJob.TABLE_NAME).withRecordEntity(new ScheduledJob()
+         .withLabel("Test")
+         .withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
+         .withType(ScheduledJobType.PROCESS.name())
+         .withIsActive(true)
+         .withRepeatSeconds(1)
+         .withJobParameters(List.of(new ScheduledJobParameter().withKey("processName").withValue(TestUtils.PROCESS_NAME_BASEPULL)))));
+
+      wrappers = QuartzTestUtils.queryQuartz();
+      assertEquals(1, wrappers.size());
+      assertThat(wrappers.get(0).trigger()).isInstanceOf(SimpleTrigger.class);
+
+      //////////////////////////////////////
+      // now do an update, to re-schedule //
+      //////////////////////////////////////
+      new UpdateAction().execute(new UpdateInput(ScheduledJob.TABLE_NAME).withRecordEntity(new ScheduledJob()
+         .withId(1)
+         .withLabel("Test")
+         .withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
+         .withType(ScheduledJobType.PROCESS.name())
+         .withIsActive(true)
+         .withRepeatSeconds(null)
+         .withCronExpression(GOOD_CRON)
+         .withCronTimeZoneId("UTC")));
+
+      wrappers = QuartzTestUtils.queryQuartz();
+      assertEquals(1, wrappers.size());
+      assertThat(wrappers.get(0).trigger()).isInstanceOf(CronTrigger.class);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testPostUpdateActionIssuesWarnings() throws QException, SchedulerException
+   {
+      List<QuartzJobAndTriggerWrapper> wrappers = QuartzTestUtils.queryQuartz();
+      assertEquals(0, wrappers.size());
+
+      //////////////////////////////////////////////////
+      // do an insert - this will originally schedule //
+      //////////////////////////////////////////////////
+      new InsertAction().execute(new InsertInput(ScheduledJob.TABLE_NAME).withRecordEntity(new ScheduledJob()
+         .withLabel("Test")
+         .withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
+         .withType(ScheduledJobType.PROCESS.name())
+         .withIsActive(true)
+         .withRepeatSeconds(1)
+         .withJobParameters(List.of(new ScheduledJobParameter().withKey("processName").withValue(TestUtils.PROCESS_NAME_BASEPULL)))));
+
+      wrappers = QuartzTestUtils.queryQuartz();
+      assertEquals(1, wrappers.size());
+      assertThat(wrappers.get(0).trigger()).isInstanceOf(SimpleTrigger.class);
+
+      //////////////////////////////////////
+      // now do an update, to re-schedule //
+      //////////////////////////////////////
+      UpdateOutput updateOutput = new UpdateAction().execute(new UpdateInput(ScheduledJob.TABLE_NAME).withRecordEntity(new ScheduledJob()
+         .withId(1)
+         .withLabel("Test")
+         .withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
+         .withType(ScheduledJobType.PROCESS.name())
+         .withIsActive(true)
+         .withRepeatSeconds(null)
+         .withCronExpression(GOOD_CRON)
+         .withCronTimeZoneId("UTC")
+         .withJobParameters(List.of(new ScheduledJobParameter().withKey("process").withValue("not")))));
+
+      assertTrue(CollectionUtils.nullSafeIsEmpty(updateOutput.getRecords().get(0).getErrors()));
+      assertThat(updateOutput.getRecords().get(0).getWarnings())
+         .hasSize(1).first().extracting("message").asString()
+         .contains("Missing scheduledJobParameter with key [processName]");
+
+      wrappers = QuartzTestUtils.queryQuartz();
+      assertEquals(0, wrappers.size());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testPostDeleteUnschedules() throws QException, SchedulerException
+   {
+      List<QuartzJobAndTriggerWrapper> wrappers = QuartzTestUtils.queryQuartz();
+      assertEquals(0, wrappers.size());
+
+      //////////////////////////////////////////////////
+      // do an insert - this will originally schedule //
+      //////////////////////////////////////////////////
+      new InsertAction().execute(new InsertInput(ScheduledJob.TABLE_NAME).withRecordEntity(new ScheduledJob()
+         .withLabel("Test")
+         .withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
+         .withType(ScheduledJobType.PROCESS.name())
+         .withIsActive(true)
+         .withRepeatSeconds(1)
+         .withJobParameters(List.of(new ScheduledJobParameter().withKey("processName").withValue(TestUtils.PROCESS_NAME_BASEPULL)))));
+
+      wrappers = QuartzTestUtils.queryQuartz();
+      assertEquals(1, wrappers.size());
+
+      ////////////////////////////////////
+      // now do a delete, to unschedule //
+      ////////////////////////////////////
+      new DeleteAction().execute(new DeleteInput(ScheduledJob.TABLE_NAME).withPrimaryKeys(List.of(1)));
+
+      wrappers = QuartzTestUtils.queryQuartz();
+      assertEquals(0, wrappers.size());
+   }
+
+}