@motif/api/lib/Scheduler.js

const _ = require("lodash")
const path = require("path")
const glob = require("glob")
const schedule = require('node-schedule-tz')
const Debugger = require("./Debugger")

const debug = new Debugger('motif:scheduler')

class Scheduler {
  get service() {
    return this._service
  }

  get config() {
    return this._service._config
  }

  constants(key) {
    let constants = process.motif.constants || {}
    return constants[key.toUpperCase()] || {}
  }

  model(key, connection = null) {
    let models = process.motif.models
    let modelData = models[key]
    if (!modelData) {
      return null
    }

    let config = this.config
    let design = modelData.design
    let model = new modelData.constructor({design, config})
    if (connection) {
      model.setCollection(design.createCollection(connection))
    }

    return model
  }

  generateJobs(options) {
    const { jobs } = options

    jobs.map((jobOptions) => {
      let { rule, timezone, controllers } = jobOptions

      const tasks = controllers.map((handler) => {
        if (timezone) {
          return schedule.scheduleJob(rule, timezone, (fireDate) => {
            let controller = async () => {
              try {
                await handler.call(this, fireDate)
              } catch (e) {
                console.error(e)
              }
            }

            controller.call(this, fireDate)
          })
        }
        else {
          return schedule.scheduleJob(rule, (fireDate) => {
            let controller = async () => {
              try {
                await handler.call(this, fireDate)
              } catch (e) {
                console.error(e)
              }
            }

            controller.call(this, fireDate)
          })
        }
      })
    })
  }

  constructor({ service }) {
    debug.log("scheduler", service)

    this._service = service
  }

  static __autoLoad( cwd, options = {}) {
    let handlers = []
    let { excludesAll, excludes, includes } = options
    let rule = options.rule || "jobs/*.js"
    let files = glob.sync(rule, { cwd: cwd })

    _.each(files, file => {
      let filePath = path.resolve(cwd, file)

      let isIgnore = excludesAll === true

      if (excludes) {
        _.forEach(excludes, exclude => {
          if (filePath.indexOf(exclude) !== -1) {
            isIgnore = true
          }
        })
      }

      if (includes) {
        _.forEach(includes || [], include => {
          if (filePath.indexOf(include) !== -1) {
            isIgnore = false
          }
        })
      }

      if (!isIgnore) {
        delete require.cache[filePath]
        let handler = require(filePath)
        handlers.push(handler)
      }
    })

    return handlers
  }
}

module.exports = Scheduler