@wmfs/tymly-schedule-plugin 1.0.1 → 1.2.0

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,11 +1,17 @@
+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')
+const { v4: uuidv4 } = require('uuid')
 
 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)) {
@@ -49,16 +55,15 @@ class CronService {
     }
 
     // todo: allow window for start/end datetimes
-
     task.job = nodeSchedule.scheduleJob(
       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,43 @@ 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 = {}) {
+    if (key === null) {
+      console.log('no key, generating...')
+      key = uuidv4()
+    }
+    this.scheduledTasks[key] = config
+    return this.persistTask(key, config)
+  } // createScheduledTask
 
   async shutdown () {
     await nodeSchedule.gracefulShutdown()

package/lib/components/services/schedule/utils/datetime-to-rule.js

@@ -7,7 +7,7 @@ module.exports = function (datetime) {
     year: datetime.getFullYear(),
     month: datetime.getMonth(),
     date: datetime.getDate(),
-    hour: datetime.getHours(),
+    hour: datetime.getHours() - 1,
     minute: datetime.getMinutes(),
     second: datetime.getSeconds()
   }

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,55 @@
+// 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(key)
+  }
+}
+
+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.2.0",
   "description": "Provides state machine scheduling for the Tymly framework",
   "homepage": "https://github.com/wmfs/tymly-schedule-plugin#readme",
   "author": "West Midlands Fire Service",
@@ -22,14 +22,16 @@
   },
   "main": "./lib/index.js",
   "dependencies": {
-    "node-schedule": "2.1.0"
+    "node-schedule": "2.1.0",
+    "uuid": "^8.3.2"
   },
   "devDependencies": {
     "@semantic-release/changelog": "6.0.1",
     "@semantic-release/exec": "6.0.3",
     "@semantic-release/git": "10.0.1",
     "@wmfs/tymly": "1.235.1",
-    "@wmfs/tymly-pg-plugin": "1.268.0",
+    "@wmfs/tymly-pg-plugin": "1.268.1",
+    "@wmfs/tymly-test-helpers": "1.17.0",
     "chai": "4.3.6",
     "codecov": "3.8.3",
     "conventional-changelog-metahub": "4.0.1",
@@ -50,9 +52,6 @@
   "config": {
     "commitizen": {
       "path": "cz-conventional-changelog"
-    },
-    "tymly": {
-      "sync": false
     }
   },
   "publishConfig": {

package/plugin.json

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

package/test/rule-to-datetime-tests.js

@@ -81,7 +81,7 @@ describe('Datetime to rule tests', function () {
     expect(rule.year).to.eql(now.getFullYear())
     expect(rule.month).to.eql(now.getMonth())
     expect(rule.date).to.eql(now.getDate())
-    expect(rule.hour).to.eql(now.getHours())
+    expect(rule.hour).to.eql(now.getHours() - 1)
     expect(rule.minute).to.eql(now.getMinutes())
     expect(rule.second).to.eql(now.getSeconds())
   })
@@ -96,7 +96,7 @@ describe('Datetime to rule tests', function () {
     expect(rule.year).to.eql(year)
     expect(rule.month).to.eql(datetime.getMonth())
     expect(rule.date).to.eql(datetime.getDate())
-    expect(rule.hour).to.eql(datetime.getHours())
+    expect(rule.hour).to.eql(datetime.getHours() - 1)
     expect(rule.minute).to.eql(datetime.getMinutes())
     expect(rule.second).to.eql(datetime.getSeconds())
   })