@wmfs/tymly-schedule-plugin 1.0.1 → 1.1.0

package/.version

@@ -1 +1 @@
-VERSION=1.0.1
+VERSION=1.1.0

package/CHANGELOG.md

@@ -1,3 +1,29 @@
+# [1.1.0](https://github.com/wmfs/tymly-schedule-plugin/compare/v1.0.1...v1.1.0) (2022-03-16)
+
+
+### ✨ Features
+
+* ability to create/modify tasks from ui ([b7d56c5](https://github.com/wmfs/tymly-schedule-plugin/commit/b7d56c5e44609d4b2b14dbdc4e13a6c91f784eee))
+* admin tools to create scheduled task ([b0e6ddc](https://github.com/wmfs/tymly-schedule-plugin/commit/b0e6ddc5325ace6332516275893471b39703c1ba))
+* admin tools to start/stop tasks ([106f5fa](https://github.com/wmfs/tymly-schedule-plugin/commit/106f5fa7daedca13030b49fac473a891c5c6d9e1))
+* admin tools to update schedule of state machine ([c6df466](https://github.com/wmfs/tymly-schedule-plugin/commit/c6df4669823e002916d4b86a0458e4e1d57ab45d))
+* admin tools to update state machine config ([e26928a](https://github.com/wmfs/tymly-schedule-plugin/commit/e26928a276c1783fb92785eb2355570dd01f32ac))
+* admin tools to view all and view specific tasks ([b9f80c8](https://github.com/wmfs/tymly-schedule-plugin/commit/b9f80c89077115ae2c783c0b03e8de322111319f))
+* admin tools to view scheduled executions ([89b9094](https://github.com/wmfs/tymly-schedule-plugin/commit/89b90941de1b48a14896043ec3710df2c2440949))
+* remove last ran start/end and total run count, as these can be found from executions ([d6c673b](https://github.com/wmfs/tymly-schedule-plugin/commit/d6c673b926654c564d08f6de1b5f22bcf61b3783))
+
+
+### 🐛 Bug Fixes
+
+* issue with finding scheduled executions ([b198bd1](https://github.com/wmfs/tymly-schedule-plugin/commit/b198bd1bf49ffb517229309eadaf7fdaed9f1ff7))
+* use function from service to get executions ([b9082bc](https://github.com/wmfs/tymly-schedule-plugin/commit/b9082bc49ccdbd39c1316c786f83efddd7396a7d))
+
+
+### 🚨 Tests
+
+* fix status after re-boot with datetime schedule in past ([e4e9cba](https://github.com/wmfs/tymly-schedule-plugin/commit/e4e9cba84fbdaf91838e880b7dacda4659e60119))
+* remove unused executions model ([92e888d](https://github.com/wmfs/tymly-schedule-plugin/commit/92e888d266803dac531a27f0c8d74ff6d6b22e52))
+
 ## [1.0.1](https://github.com/wmfs/tymly-schedule-plugin/compare/v1.0.0...v1.0.1) (2022-03-15)
 
 

package/lib/blueprints/schedule-blueprint/card-templates/create-scheduled-task.json

@@ -0,0 +1,97 @@
+{
+  "templateMeta": {
+    "name": "create-scheduled-task",
+    "title": "Configure a Scheduled State Machine",
+    "category": "schedule"
+  },
+  "hooks": {
+    "afterSubmit": {
+      "actions": [
+        {
+          "type": "Action.PushCard",
+          "stateMachineName": "schedule_viewScheduledTask_1_0",
+          "input": {
+            "key": "$.key"
+          }
+        }
+      ]
+    }
+  },
+  "type": "AdaptiveCard",
+  "body": [
+    {
+      "showWhen": "data.editing !== true",
+      "id": "name",
+      "type": "Input.Text",
+      "title": "Schedule name",
+      "validation": {
+        "requiredIf": "data.editing !== true"
+      }
+    },
+    {
+      "id": "scheduleType",
+      "type": "Input.ChoiceSet",
+      "title": "What type of schedule?",
+      "choices": [
+        {
+          "title": "Interval",
+          "value": "interval"
+        },
+        {
+          "title": "Date/time",
+          "value": "datetime"
+        }
+      ],
+      "validation": {
+        "required": true
+      }
+    },
+    {
+      "showWhen": "data.scheduleType === 'interval'",
+      "id": "interval",
+      "type": "Input.Text",
+      "title": "Interval",
+      "validation": {
+        "requiredIf": "data.scheduleType === 'interval'"
+      }
+    },
+    {
+      "showWhen": "data.scheduleType === 'datetime'",
+      "id": "datetime",
+      "type": "Input.DateTime",
+      "title": "Date/time",
+      "validation": {
+        "requiredIf": "data.scheduleType === 'datetime'"
+      }
+    },
+    {
+      "id": "stateMachineName",
+      "type": "Input.ChoiceSet",
+      "title": "Which state machine?",
+      "filter": true,
+      "choicesPath": "data.availableStateMachines",
+      "validation": {
+        "required": true
+      }
+    },
+    {
+      "id": "inputStr",
+      "type": "Input.Text",
+      "title": "Input",
+      "isMultiline": true,
+      "value": "{}"
+    }
+  ],
+  "actions": [
+    {
+      "type": "Action.Cancel",
+      "title": "Cancel"
+    },
+    {
+      "type": "Action.Submit",
+      "title": "Submit"
+    }
+  ],
+  "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
+  "version": "1.0"
+}

package/lib/blueprints/schedule-blueprint/card-templates/view-all-scheduled-tasks.json

@@ -0,0 +1,36 @@
+{
+  "templateMeta": {
+    "name": "view-scheduled-tasks",
+    "title": "View Scheduled State Machines",
+    "category": "schedule"
+  },
+  "type": "AdaptiveCard",
+  "body": [
+    {
+      "type": "MarkupTable",
+      "title": "Scheduled State Machines",
+      "arrayPath": "data.tasks",
+      "clickToLaunch": true,
+      "columns": [
+        {
+          "title": "Key",
+          "value": "{{ item.key }}"
+        },
+        {
+          "title": "Schedule",
+          "value": "{{ item.scheduleType === 'datetime' ? item.datetime : item.interval }}"
+        },
+        {
+          "title": "State machine name",
+          "value": "{{ item.stateMachineName }}"
+        },
+        {
+          "title": "Status",
+          "value": "{{ item.status }}"
+        }
+      ]
+    }
+  ],
+  "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
+  "version": "1.0"
+}

package/lib/blueprints/schedule-blueprint/card-templates/view-scheduled-task.json

@@ -0,0 +1,148 @@
+{
+  "templateMeta": {
+    "name": "view-scheduled-task",
+    "title": "View Scheduled State Machine",
+    "category": "schedule"
+  },
+  "type": "AdaptiveCard",
+  "body": [
+    {
+      "type": "Container",
+      "color": "accent",
+      "spacing": "none",
+      "items": [
+        {
+          "type": "TextBlock",
+          "text": "{{ data.key }}",
+          "weight": "bolder",
+          "spacing": "none"
+        }
+      ]
+    },
+    {
+      "type": "ColumnSet",
+      "columns": [
+        {
+          "type": "Column",
+          "width": 8,
+          "items": [
+            {
+              "type": "FactSet",
+              "showAllIfUndefined": true,
+              "facts": [
+                {
+                  "title": "Key",
+                  "value": "{{ data.key }}"
+                },
+                {
+                  "title": "Schedule",
+                  "value": "{{ data.scheduleType === 'datetime' ? data.datetime : data.interval }}"
+                },
+                {
+                  "title": "State machine name",
+                  "value": "{{ data.stateMachineName }}"
+                },
+                {
+                  "title": "Input",
+                  "value": "{{ JSON.stringify(data.input) }}"
+                },
+                {
+                  "title": "Send response",
+                  "value": "{{ data.sendResponse }}"
+                },
+                {
+                  "title": "Start on boot?",
+                  "value": "{{ data.startOnBoot ? 'Yes' : 'No' }}"
+                },
+                {
+                  "title": "Status",
+                  "value": "{{ data.status }}"
+                },
+                {
+                  "title": "Created",
+                  "value": "{{ formatDate(data.created, 'DD/MM/YYYY HH:mm') }}"
+                },
+                {
+                  "title": "Created by",
+                  "value": "{{ data.createdBy || '-' }}"
+                },
+                {
+                  "title": "Modified",
+                  "value": "{{ formatDate(data.modified, 'DD/MM/YYYY HH:mm') }}"
+                },
+                {
+                  "title": "Modified by",
+                  "value": "{{ data.modifiedBy || '-' }}"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "type": "Column",
+          "width": 4,
+          "items": [
+            {
+              "type": "ActionSet",
+              "actions": [
+                {
+                  "showWhen": "data.status === 'STARTED'",
+                  "type": "Action.PushCard",
+                  "title": "Stop task",
+                  "stateMachineName": "schedule_stopTask_1_0",
+                  "input": {
+                    "key": "$.key"
+                  }
+                },
+                {
+                  "showWhen": "data.status !== 'STARTED'",
+                  "type": "Action.PushCard",
+                  "title": "Start task",
+                  "stateMachineName": "schedule_startTask_1_0",
+                  "input": {
+                    "key": "$.key"
+                  }
+                },
+                {
+                  "type": "Action.PushCard",
+                  "title": "Modify schedule",
+                  "stateMachineName": "schedule_modifyScheduledTask_1_0",
+                  "input": {
+                    "key": "$.key"
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "title": "State machine executions",
+      "type": "Table",
+      "arrayPath": "data.executions",
+      "columns": [
+        {
+          "title": "Execution name",
+          "field": "executionName"
+        },
+        {
+          "title": "Status",
+          "field": "status"
+        },
+        {
+          "title": "Created",
+          "field": "created",
+          "format": "formatDate(val, 'DD/MM/YYYY HH:mm')"
+        },
+        {
+          "title": "Modified",
+          "field": "modified",
+          "format": "formatDate(val, 'DD/MM/YYYY HH:mm')"
+        }
+      ]
+    }
+  ],
+  "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
+  "version": "1.0"
+}

package/lib/blueprints/schedule-blueprint/categories/schedule.json

@@ -0,0 +1,8 @@
+{
+  "label": "Schedule",
+  "description": "Scheduled state machines",
+  "style": {
+    "icon": "schedule",
+    "backgroundColor": "#008800"
+  }
+}

package/lib/blueprints/schedule-blueprint/functions/generate-key.js

@@ -0,0 +1,16 @@
+const capitalise = str => str.charAt(0).toUpperCase() + str.slice(1)
+const schema = 'schedule'
+
+module.exports = function () {
+  return function (event, env) {
+    const now = env.bootedServices.timestamp.now()
+
+    const key = [
+      schema,
+      event.trim().split(' ').map((n, i) => i === 0 ? n : capitalise(n)).join(''),
+      now.format('YYYYMMDD-HHmm')
+    ].join('_')
+
+    return { key }
+  }
+}

package/lib/blueprints/schedule-blueprint/functions/get-available-state-machines.js

@@ -0,0 +1,18 @@
+module.exports = function () {
+  return async function getAvailableStateMachines (event, env) {
+    const availableStateMachines = env.bootedServices.statebox
+      .listStateMachines()
+      .map(({ name }) => {
+        return {
+          title: name,
+          value: name
+        }
+      })
+
+    return {
+      availableStateMachines,
+      availableStateMachinesOrig: availableStateMachines,
+      availableStateMachinesFilt: availableStateMachines
+    }
+  }
+}

package/lib/blueprints/schedule-blueprint/models/task.json

@@ -35,20 +35,6 @@
     "startOnBoot": {
       "type": "boolean"
     },
-    "lastRanStart": {
-      "type": "string",
-      "format": "date-time"
-    },
-    "lastRanEnd": {
-      "type": "string",
-      "format": "date-time"
-    },
-    "lastRanExecutionName": {
-      "type": "string"
-    },
-    "totalRunCount": {
-      "type": "integer"
-    },
     "status": {
       "type": "string"
     }

package/lib/blueprints/schedule-blueprint/state-machines/create-scheduled-task.json

@@ -0,0 +1,66 @@
+{
+  "Comment": "Set up a Scheduled State Machine",
+  "name": "Set up a Scheduled State Machine",
+  "version": "1.0",
+  "categories": [
+    "schedule"
+  ],
+  "instigators": [
+    "user"
+  ],
+  "instigatorGroup": "form",
+  "StartAt": "GetStateMachines",
+  "States": {
+    "GetStateMachines": {
+      "Type": "Task",
+      "Resource": "function:schedule_getAvailableStateMachines",
+      "ResultPath": "$",
+      "Next": "DefaultInput"
+    },
+    "DefaultInput": {
+      "Type": "Pass",
+      "ResultSelector": {
+        "inputStr": "{}"
+      },
+      "Next": "View"
+    },
+    "View": {
+      "Type": "Task",
+      "Resource": "module:awaitingHumanInput",
+      "ResourceConfig": {
+        "uiType": "app",
+        "uiName": "schedule_createScheduledTask",
+        "dataPath": "$"
+      },
+      "Next": "GenerateKey"
+    },
+    "GenerateKey": {
+      "Type": "Task",
+      "InputPath": "$.name",
+      "Resource": "function:schedule_generateKey",
+      "ResultPath": "$",
+      "Next": "CreateScheduledTask"
+    },
+    "CreateScheduledTask": {
+      "Type": "Task",
+      "Parameters": {
+        "key.$": "$.key",
+        "scheduleType.$": "$.scheduleType",
+        "datetime.$": "$.datetime",
+        "interval.$": "$.interval",
+        "stateMachineName.$": "$.stateMachineName",
+        "input.$": "$.inputStr"
+      },
+      "Resource": "module:createScheduledTask",
+      "End": true
+    }
+  },
+  "restrictions": [
+    {
+      "roleId": "schedule_scheduleAdmin",
+      "allows": [
+        "*"
+      ]
+    }
+  ]
+}

package/lib/blueprints/schedule-blueprint/state-machines/modify-scheduled-task.json

@@ -0,0 +1,74 @@
+{
+  "Comment": "Modify a Scheduled State Machine",
+  "name": "Modify a Scheduled State Machine",
+  "version": "1.0",
+  "categories": [
+    "schedule"
+  ],
+  "StartAt": "SetAsEditing",
+  "States": {
+    "SetAsEditing": {
+      "Type": "Pass",
+      "Result": {
+        "editing": true
+      },
+      "ResultPath": "$",
+      "Next": "FindTask"
+    },
+    "FindTask": {
+      "Type": "Task",
+      "InputPath": "$.key",
+      "Resource": "module:findingById",
+      "ResourceConfig": {
+        "modelId": "schedule_task"
+      },
+      "ResultPath": "$",
+      "Next": "GetStateMachines"
+    },
+    "GetStateMachines": {
+      "Type": "Task",
+      "Resource": "function:schedule_getAvailableStateMachines",
+      "ResultPath": "$",
+      "Next": "View"
+    },
+    "View": {
+      "Type": "Task",
+      "Resource": "module:awaitingHumanInput",
+      "ResourceConfig": {
+        "uiType": "app",
+        "uiName": "schedule_createScheduledTask",
+        "dataPath": "$"
+      },
+      "Next": "UpdateScheduledTask"
+    },
+    "UpdateScheduledTask": {
+      "Type": "Task",
+      "Parameters": {
+        "key.$": "$.key",
+        "scheduleType.$": "$.scheduleType",
+        "datetime.$": "$.datetime",
+        "interval.$": "$.interval"
+      },
+      "Resource": "module:updateScheduledTask",
+      "Next": "UpdateScheduledStateMachineConfig"
+    },
+    "UpdateScheduledStateMachineConfig": {
+      "Type": "Task",
+      "Parameters": {
+        "key.$": "$.key",
+        "stateMachineName.$": "$.stateMachineName",
+        "input.$": "$.inputStr"
+      },
+      "Resource": "module:updateScheduledStateMachineConfig",
+      "End": true
+    }
+  },
+  "restrictions": [
+    {
+      "roleId": "schedule_scheduleAdmin",
+      "allows": [
+        "*"
+      ]
+    }
+  ]
+}

package/lib/blueprints/schedule-blueprint/state-machines/start-task.json

@@ -0,0 +1,36 @@
+{
+  "Comment": "Start Scheduled State Machine",
+  "name": "Start Scheduled State Machine",
+  "version": "1.0",
+  "categories": [
+    "schedule"
+  ],
+  "StartAt": "StartScheduledTask",
+  "States": {
+    "StartScheduledTask": {
+      "Type": "Task",
+      "InputPath": "$.key",
+      "Resource": "module:startScheduledTask",
+      "Next": "View"
+    },
+    "View": {
+      "Type": "Task",
+      "Parameters": {
+        "key.$": "$.key"
+      },
+      "Resource": "module:runStateMachine",
+      "ResourceConfig": {
+        "stateMachine": "schedule_viewScheduledTask_1_0"
+      },
+      "End": true
+    }
+  },
+  "restrictions": [
+    {
+      "roleId": "schedule_scheduleAdmin",
+      "allows": [
+        "*"
+      ]
+    }
+  ]
+}

package/lib/blueprints/schedule-blueprint/state-machines/stop-task.json

@@ -0,0 +1,36 @@
+{
+  "Comment": "Stop Scheduled State Machine",
+  "name": "Stop Scheduled State Machine",
+  "version": "1.0",
+  "categories": [
+    "schedule"
+  ],
+  "StartAt": "StopScheduledTask",
+  "States": {
+    "StopScheduledTask": {
+      "Type": "Task",
+      "InputPath": "$.key",
+      "Resource": "module:stopScheduledTask",
+      "Next": "View"
+    },
+    "View": {
+      "Type": "Task",
+      "Parameters": {
+        "key.$": "$.key"
+      },
+      "Resource": "module:runStateMachine",
+      "ResourceConfig": {
+        "stateMachine": "schedule_viewScheduledTask_1_0"
+      },
+      "End": true
+    }
+  },
+  "restrictions": [
+    {
+      "roleId": "schedule_scheduleAdmin",
+      "allows": [
+        "*"
+      ]
+    }
+  ]
+}

package/lib/blueprints/schedule-blueprint/state-machines/view-all-scheduled-tasks.json

@@ -0,0 +1,69 @@
+{
+  "Comment": "View Scheduled State Machines",
+  "name": "View Scheduled State Machines",
+  "version": "1.0",
+  "categories": [
+    "schedule"
+  ],
+  "instigators": [
+    "user"
+  ],
+  "instigatorGroup": "app",
+  "StartAt": "FindTasks",
+  "States": {
+    "FindTasks": {
+      "Type": "Task",
+      "Resource": "module:finding",
+      "ResourceConfig": {
+        "modelId": "schedule_task"
+      },
+      "ResultPath": "$.tasks",
+      "Next": "AddTaskLaunches"
+    },
+    "AddTaskLaunches": {
+      "Type": "Map",
+      "ItemsPath": "$.tasks",
+      "Iterator": {
+        "StartAt": "AddLaunches",
+        "States": {
+          "AddLaunches": {
+            "Type": "Pass",
+            "Parameters": {
+              "launches": [
+                {
+                  "title": "View",
+                  "stateMachineName": "schedule_viewScheduledTask",
+                  "input": {
+                    "key.$": "$.key"
+                  }
+                }
+              ]
+            },
+            "ResultPath": "$",
+            "End": true
+          }
+        }
+      },
+      "ResultPath": "$.tasks",
+      "Next": "View"
+    },
+    "View": {
+      "Type": "Task",
+      "Resource": "module:awaitingHumanInput",
+      "ResourceConfig": {
+        "uiType": "app",
+        "uiName": "schedule_viewAllScheduledTasks",
+        "dataPath": "$"
+      },
+      "End": true
+    }
+  },
+  "restrictions": [
+    {
+      "roleId": "schedule_scheduleAdmin",
+      "allows": [
+        "*"
+      ]
+    }
+  ]
+}

package/lib/blueprints/schedule-blueprint/state-machines/view-scheduled-task.json

@@ -0,0 +1,46 @@
+{
+  "Comment": "View Scheduled State Machine",
+  "name": "View Scheduled State Machine",
+  "version": "1.0",
+  "categories": [
+    "schedule"
+  ],
+  "StartAt": "FindTask",
+  "States": {
+    "FindTask": {
+      "Type": "Task",
+      "InputPath": "$.key",
+      "Resource": "module:findingById",
+      "ResourceConfig": {
+        "modelId": "schedule_task"
+      },
+      "ResultPath": "$",
+      "Next": "FindExecutions"
+    },
+    "FindExecutions": {
+      "Type": "Task",
+      "InputPath": "$.key",
+      "Resource": "module:findScheduledExecutions",
+      "ResultPath": "$.executions",
+      "Next": "View"
+    },
+    "View": {
+      "Type": "Task",
+      "Resource": "module:awaitingHumanInput",
+      "ResourceConfig": {
+        "uiType": "app",
+        "uiName": "schedule_viewScheduledTask",
+        "dataPath": "$"
+      },
+      "End": true
+    }
+  },
+  "restrictions": [
+    {
+      "roleId": "schedule_scheduleAdmin",
+      "allows": [
+        "*"
+      ]
+    }
+  ]
+}

package/lib/blueprints/schedule-blueprint/template-roles/schedule-admin.json

@@ -0,0 +1,4 @@
+{
+  "label": "Schedule Admin",
+  "description": "Maintain scheduled state machines"
+}

package/lib/components/services/schedule/index.js

@@ -1,3 +1,5 @@
+const INSTIGATING_CLIENT_DOMAIN = 'tymly-schedule-plugin'
+
 const nodeSchedule = require('node-schedule')
 const ruleToDatetime = require('./utils/rule-to-datetime')
 const datetimeToRule = require('./utils/datetime-to-rule')
@@ -6,6 +8,9 @@ class CronService {
   async boot (options) {
     this.statebox = options.bootedServices.statebox
     this.taskModel = options.bootedServices.storage.models.schedule_task
+    this.executionModel = options.bootedServices.storage.models.tymly_execution
+
+    // todo: rename blueprint component to scheduled-tasks, blueprint component to have "type": "stateMachineName"
     this.scheduledTasks = await this.findTasks(options.blueprintComponents.stateMachineSchedules)
 
     for (const [key, task] of Object.entries(this.scheduledTasks)) {
@@ -54,11 +59,11 @@ class CronService {
       jobOptions,
       () => {
         console.log(`Running scheduled state machine ${stateMachineName}`)
-        const startedAt = new Date()
         const executionOptions = {
           instigatingClient: {
             appName: 'tymly',
-            domain: 'tymly-schedule-plugin'
+            domain: INSTIGATING_CLIENT_DOMAIN,
+            scheduleKey: key
           },
           sendResponse
         }
@@ -66,7 +71,6 @@ class CronService {
           if (err) {
             console.log(`There was an error on execution of scheduled state machine ${stateMachineName}`)
           }
-          await this.updateTaskOnExecution(key, executionDescription.executionName, startedAt)
         }
         this.statebox.startExecution(input, stateMachineName, executionOptions, cb)
       }
@@ -74,7 +78,7 @@ class CronService {
 
     this.scheduledTasks[key] = task
 
-    return this.updateTaskStatus(key, 'STARTED')
+    return this.updateTaskStatus(key, task.job === null ? 'STOPPED' : 'STARTED')
   } // startTask
 
   stopTask (key) {
@@ -105,7 +109,7 @@ class CronService {
         setMissingPropertiesToNull: false
       }
     )
-  }
+  } // updateTaskStatus
 
   stopTasks () {
     return Promise.all(
@@ -129,6 +133,11 @@ class CronService {
         continue
       }
 
+      const stateMachineOk = this.checkIfStateMachineExists(config.stateMachineName)
+      if (!stateMachineOk) {
+        continue
+      }
+
       // todo: recurrence rules?
 
       if (typeof config.interval === 'string') {
@@ -140,6 +149,10 @@ class CronService {
         config.interval = null
       }
 
+      config.input = typeof config.input === 'object'
+        ? config.input
+        : {}
+
       tasks[key] = config
 
       await this.persistTask(key, config)
@@ -158,35 +171,44 @@ class CronService {
       interval: config.interval,
       datetime: config.datetime,
       startOnBoot: config.startOnBoot,
-      lastRanStart: null,
-      lastRanEnd: null,
-      lastRanExecutionName: null,
-      totalRunCount: 0,
       status: null
     })
-  }
+  } // persistTask
 
-  async updateTaskOnExecution (key, executionName, startedAt) {
-    const { totalRunCount } = await this.taskModel.findOne(
-      {
-        where: { key: { equals: key } },
-        fields: ['totalRunCount']
-      }
-    )
+  checkIfStateMachineExists (stateMachineName) {
+    const [stateMachineOk, errStateMachineDesc] = this.statebox.checkIfStateMachineExists(stateMachineName)
+
+    if (!stateMachineOk) {
+      console.log('State machine error', errStateMachineDesc)
+    }
+
+    return stateMachineOk
+  } // checkIfStateMachineExists
+
+  async stopAndUpdateStateMachineConfig (key, stateMachineName, input) {
+    await this.stopTask(key)
+
+    const stateMachineOk = this.checkIfStateMachineExists(stateMachineName)
+    if (!stateMachineOk) {
+      return
+    }
+
+    this.scheduledTasks[key].stateMachineName = stateMachineName
+    this.scheduledTasks[key].input = typeof input === 'object'
+      ? input
+      : {}
 
     return this.taskModel.update(
       {
         key,
-        lastRanStart: startedAt,
-        lastRanEnd: new Date(),
-        lastRanExecutionName: executionName,
-        totalRunCount: totalRunCount + 1
+        stateMachineName: this.scheduledTasks[key].stateMachineName,
+        input: this.scheduledTasks[key].input
       },
       {
         setMissingPropertiesToNull: false
       }
     )
-  }
+  } // stopAndUpdateStateMachineConfig
 
   async stopAndUpdateTaskSchedule (key, rule) {
     await this.stopTask(key)
@@ -212,7 +234,39 @@ class CronService {
         setMissingPropertiesToNull: false
       }
     )
-  }
+  } // stopAndUpdateTaskSchedule
+
+  async findScheduledExecutions (key) {
+    const executions = await this.executionModel.find({
+      fields: [
+        'executionName',
+        'executionOptions',
+        'status',
+        'created',
+        'modified'
+      ],
+      where: {
+        stateMachineName: {
+          equals: this.scheduledTasks[key].stateMachineName
+        }
+      },
+      orderBy: ['-modified']
+    })
+
+    return executions.filter(({ executionOptions }) => {
+      executionOptions = typeof executionOptions === 'string'
+        ? JSON.parse(executionOptions)
+        : executionOptions
+
+      return executionOptions.instigatingClient.domain === INSTIGATING_CLIENT_DOMAIN &&
+        executionOptions.instigatingClient.scheduleKey === key
+    })
+  } // findScheduledExecutions
+
+  createScheduledTask (key, config = {}) {
+    this.scheduledTasks[key] = config
+    return this.persistTask(key, config)
+  } // createScheduledTask
 
   async shutdown () {
     await nodeSchedule.gracefulShutdown()

package/lib/components/state-resources/create-scheduled-task/doc/example.json

@@ -0,0 +1,8 @@
+{
+  "CreateScheduledTask": {
+    "Type": "Task",
+    "InputPath": "$.key",
+    "Resource": "module:createScheduledTask",
+    "End": true
+  }
+}

package/lib/components/state-resources/create-scheduled-task/doc/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  description: 'Create task',
+  example: require('./example.json')
+}

package/lib/components/state-resources/create-scheduled-task/index.js

@@ -0,0 +1,56 @@
+// const datetimeToRule = require('../../services/schedule/utils/datetime-to-rule')
+
+class CreateScheduledTask {
+  init (resourceConfig, env) {
+    this.services = env.bootedServices
+  }
+
+  async run (event, context) {
+    const {
+      key,
+      stateMachineName,
+      scheduleType,
+      datetime,
+      interval
+    } = event
+
+    const stateMachineOk = this.services.schedule.checkIfStateMachineExists(stateMachineName)
+    if (!stateMachineOk) {
+      return context.sendTaskSuccess()
+    }
+
+    let input = typeof event.input === 'object'
+      ? event.input
+      : {}
+
+    if (typeof event.input === 'string') {
+      try {
+        input = JSON.parse(event.input)
+      } catch (err) {
+        console.log('Issue with input', event.input)
+      }
+    }
+
+    // const rule = scheduleType === 'interval'
+    //   ? interval
+    //   : datetimeToRule(new Date(datetime))
+
+    const config = {
+      stateMachineName,
+      input,
+      sendResponse: 'COMPLETE',
+      scheduleType,
+      interval,
+      datetime,
+      startOnBoot: false // todo
+    }
+
+    await this.services.schedule.createScheduledTask(key, config)
+    // await this.services.schedule.stopAndUpdateTaskSchedule(key, rule)
+    // await this.services.schedule.stopAndUpdateStateMachineConfig(key, stateMachineName, input)
+
+    return context.sendTaskSuccess()
+  }
+}
+
+module.exports = CreateScheduledTask

package/lib/components/state-resources/find-scheduled-executions/doc/example.json

@@ -0,0 +1,8 @@
+{
+  "FindScheduledExecutions": {
+    "Type": "Task",
+    "InputPath": "$.key",
+    "Resource": "module:findScheduledExecutions",
+    "End": true
+  }
+}

package/lib/components/state-resources/find-scheduled-executions/doc/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  description: 'Find scheduled executions',
+  example: require('./example.json')
+}

package/lib/components/state-resources/find-scheduled-executions/index.js

@@ -0,0 +1,12 @@
+class FindScheduledExecutions {
+  init (resourceConfig, env) {
+    this.services = env.bootedServices
+  }
+
+  async run (key, context) {
+    const executions = await this.services.schedule.findScheduledExecutions(key)
+    return context.sendTaskSuccess(executions)
+  }
+}
+
+module.exports = FindScheduledExecutions

package/lib/components/state-resources/start-scheduled-task/doc/example.json

@@ -0,0 +1,8 @@
+{
+  "StartScheduledTask": {
+    "Type": "Task",
+    "InputPath": "$.key",
+    "Resource": "module:startScheduledTask",
+    "End": true
+  }
+}

package/lib/components/state-resources/start-scheduled-task/doc/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  description: 'Start task',
+  example: require('./example.json')
+}

package/lib/components/state-resources/start-scheduled-task/index.js

@@ -0,0 +1,12 @@
+class StartScheduledTask {
+  init (resourceConfig, env) {
+    this.services = env.bootedServices
+  }
+
+  async run (key, context) {
+    await this.services.schedule.startTask(key)
+    return context.sendTaskSuccess()
+  }
+}
+
+module.exports = StartScheduledTask

package/lib/components/state-resources/stop-scheduled-task/doc/example.json

@@ -0,0 +1,8 @@
+{
+  "StopScheduledTask": {
+    "Type": "Task",
+    "InputPath": "$.key",
+    "Resource": "module:stopScheduledTask",
+    "End": true
+  }
+}

package/lib/components/state-resources/stop-scheduled-task/doc/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  description: 'Stop task',
+  example: require('./example.json')
+}

package/lib/components/state-resources/stop-scheduled-task/index.js

@@ -0,0 +1,12 @@
+class StopScheduledTask {
+  init (resourceConfig, env) {
+    this.services = env.bootedServices
+  }
+
+  async run (key, context) {
+    await this.services.schedule.stopTask(key)
+    return context.sendTaskSuccess()
+  }
+}
+
+module.exports = StopScheduledTask

package/lib/components/state-resources/update-scheduled-state-machine-config/doc/example.json

@@ -0,0 +1,12 @@
+{
+  "UpdateScheduledStateMachineConfig": {
+    "Type": "Task",
+    "Parameters": {
+      "key.$": "$.key",
+      "stateMachineName.$": "$.stateMachineName",
+      "input.$": "$.input"
+    },
+    "Resource": "module:updateScheduledStateMachineConfig",
+    "End": true
+  }
+}

package/lib/components/state-resources/update-scheduled-state-machine-config/doc/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  description: 'Update state machine config',
+  example: require('./example.json')
+}

package/lib/components/state-resources/update-scheduled-state-machine-config/index.js

@@ -0,0 +1,35 @@
+class UpdateScheduledStateMachineConfig {
+  init (resourceConfig, env) {
+    this.services = env.bootedServices
+  }
+
+  async run (event, context) {
+    const {
+      key,
+      stateMachineName
+    } = event
+
+    const stateMachineOk = this.services.schedule.checkIfStateMachineExists(stateMachineName)
+    if (!stateMachineOk) {
+      return context.sendTaskSuccess()
+    }
+
+    let input = typeof event.input === 'object'
+      ? event.input
+      : {}
+
+    if (typeof event.input === 'string') {
+      try {
+        input = JSON.parse(event.input)
+      } catch (err) {
+        console.log('Issue with input', event.input)
+      }
+    }
+
+    await this.services.schedule.stopAndUpdateStateMachineConfig(key, stateMachineName, input)
+
+    return context.sendTaskSuccess()
+  }
+}
+
+module.exports = UpdateScheduledStateMachineConfig

package/lib/components/state-resources/update-scheduled-task/doc/example.json

@@ -0,0 +1,13 @@
+{
+  "UpdateScheduledTask": {
+    "Type": "Task",
+    "Parameters": {
+      "key.$": "$.key",
+      "scheduleType.$": "$.scheduleType",
+      "datetime.$": "$.datetime",
+      "interval.$": "$.interval"
+    },
+    "Resource": "module:updateScheduledTask",
+    "End": true
+  }
+}

package/lib/components/state-resources/update-scheduled-task/doc/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  description: 'Update task',
+  example: require('./example.json')
+}

package/lib/components/state-resources/update-scheduled-task/index.js

@@ -0,0 +1,26 @@
+const datetimeToRule = require('../../services/schedule/utils/datetime-to-rule')
+
+class UpdateScheduledTask {
+  init (resourceConfig, env) {
+    this.services = env.bootedServices
+  }
+
+  async run (event, context) {
+    const {
+      key,
+      scheduleType,
+      datetime,
+      interval
+    } = event
+
+    const rule = scheduleType === 'interval'
+      ? interval
+      : datetimeToRule(new Date(datetime))
+
+    await this.services.schedule.stopAndUpdateTaskSchedule(key, rule)
+
+    return context.sendTaskSuccess()
+  }
+}
+
+module.exports = UpdateScheduledTask

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wmfs/tymly-schedule-plugin",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Provides state machine scheduling for the Tymly framework",
   "homepage": "https://github.com/wmfs/tymly-schedule-plugin#readme",
   "author": "West Midlands Fire Service",
@@ -30,6 +30,7 @@
     "@semantic-release/git": "10.0.1",
     "@wmfs/tymly": "1.235.1",
     "@wmfs/tymly-pg-plugin": "1.268.0",
+    "@wmfs/tymly-test-helpers": "1.16.0",
     "chai": "4.3.6",
     "codecov": "3.8.3",
     "conventional-changelog-metahub": "4.0.1",

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "schedule-plugin",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "label": "Tymly Schedule Plugin",
   "author": "WMFS",
   "organisation": "West Midlands Fire Service",

package/test/schedule-tests.js

@@ -18,9 +18,7 @@ describe('Tymly schedule tests', function () {
 
   let tymlyService
   let scheduleService
-  // let statebox
   let catStatsModel
-  // let executionsModel
   let taskModel
   let client
 
@@ -34,17 +32,16 @@ describe('Tymly schedule tests', function () {
         ],
         pluginPaths: [
           path.resolve(__dirname, '..'),
-          require.resolve('@wmfs/tymly-pg-plugin')
+          require.resolve('@wmfs/tymly-pg-plugin'),
+          require.resolve('@wmfs/tymly-test-helpers/plugins/mock-users-plugin')
         ]
       }
     )
 
     tymlyService = tymlyServices.tymly
     scheduleService = tymlyServices.schedule
-    // statebox = tymlyServices.statebox
     taskModel = tymlyServices.storage.models.schedule_task
     catStatsModel = tymlyServices.storage.models.tymlyTest_catStats
-    // executionsModel = tymlyServices.storage.models.tymly_execution
     client = tymlyServices.storage.client
 
     const catStats = await catStatsModel.find({})
@@ -74,9 +71,8 @@ describe('Tymly schedule tests', function () {
     expect(tasks[0].datetime).to.eql(null)
     expect(tasks[0].status).to.eql('STOPPED')
 
-    const { totalRunCount } = tasks[0]
-
-    lastRunCount = totalRunCount
+    const executions = await scheduleService.findScheduledExecutions(scheduleKey)
+    lastRunCount = executions.length
 
     // Waited 10 seconds and runs every 2 seconds so can be 5 or 6
     expect(lastRunCount).to.be.greaterThanOrEqual(5)
@@ -96,7 +92,8 @@ describe('Tymly schedule tests', function () {
     expect(tasks[0].datetime).to.eql(null)
     expect(tasks[0].status).to.eql('STOPPED')
 
-    expect(tasks[0].totalRunCount).to.eql(lastRunCount)
+    const executions = await scheduleService.findScheduledExecutions(scheduleKey)
+    expect(executions.length).to.eql(lastRunCount)
 
     const catStats = await catStatsModel.find({})
     expect(catStats.length).to.eql(lastRunCount)
@@ -131,9 +128,11 @@ describe('Tymly schedule tests', function () {
     expect(tasks[0].interval).to.eql(null)
     expect(tasks[0].datetime).to.not.eql(null)
     expect(tasks[0].scheduleType).to.eql('datetime')
-    expect(tasks[0].totalRunCount).to.eql(lastRunCount)
     expect(tasks[0].status).to.eql('STARTED')
 
+    const executions = await scheduleService.findScheduledExecutions(scheduleKey)
+    expect(executions.length).to.eql(lastRunCount)
+
     const catStats = await catStatsModel.find({})
     expect(catStats.length).to.eql(lastRunCount)
   })
@@ -145,7 +144,8 @@ describe('Tymly schedule tests', function () {
     expect(tasks.length).to.eql(1)
     expect(tasks[0].status).to.eql('STARTED')
 
-    expect(tasks[0].totalRunCount).to.eql(lastRunCount)
+    const executions = await scheduleService.findScheduledExecutions(scheduleKey)
+    expect(executions.length).to.eql(lastRunCount)
 
     const catStats = await catStatsModel.find({})
     expect(catStats.length).to.eql(lastRunCount)
@@ -163,7 +163,8 @@ describe('Tymly schedule tests', function () {
         ],
         pluginPaths: [
           path.resolve(__dirname, '..'),
-          require.resolve('@wmfs/tymly-pg-plugin')
+          require.resolve('@wmfs/tymly-pg-plugin'),
+          require.resolve('@wmfs/tymly-test-helpers/plugins/mock-users-plugin')
         ]
       }
     )
@@ -182,8 +183,10 @@ describe('Tymly schedule tests', function () {
     expect(tasks[0].stateMachineName).to.eql('tymlyTest_sendCatUpdate')
     expect(tasks[0].scheduleType).to.eql('datetime')
     expect(tasks[0].interval).to.eql(null)
-    expect(tasks[0].status).to.eql('STARTED')
-    expect(tasks[0].totalRunCount).to.eql(lastRunCount)
+    expect(tasks[0].status).to.eql('STOPPED')
+
+    const executions = await scheduleService.findScheduledExecutions(scheduleKey)
+    expect(executions.length).to.eql(lastRunCount)
   })
 
   it('clean up data', async () => {