@wmfs/tymly-schedule-plugin 1.0.0 → 1.1.0

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(
@@ -113,7 +117,7 @@ class CronService {
     )
   } // stopTasks
 
-  async findTasks (blueprintTasks) {
+  async findTasks (blueprintTasks = {}) {
     const tasks = {}
 
     // From database
@@ -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.0",
+  "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.0",
+  "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 () => {