clockface 1.0.0.beta

data/app/controllers/clockface/application_controller.rb

@@ -0,0 +1,20 @@
+module Clockface
+  class ApplicationController < ActionController::Base
+    include ConfigHelper
+    include LoggingHelper
+
+    CAPTCHA_LENGTH = 5
+
+    protect_from_forgery with: :exception
+
+    private
+
+    def xhr_request?
+      (defined? request) && request.xhr?
+    end
+
+    def captcha_for(obj)
+      Digest::SHA1.hexdigest(obj.id.to_s).first(CAPTCHA_LENGTH)
+    end
+  end
+end

data/app/controllers/clockface/events_controller.rb

@@ -0,0 +1,151 @@
+module Clockface
+  class EventsController < ApplicationController
+    CAPTCHA_LENGTH = 5
+
+    def index
+      @events = all_events.map { |event| Clockface::EventsPresenter.new(event) }
+    end
+
+    def new
+    end
+
+    def create
+      event = Clockface::Event.new(events_params_for_create)
+      validation = validate_event(event)
+
+      if validation.failure?
+        flash[:error] = validation.errors
+        redirect_to clockface.new_event_path
+        return
+      end
+
+      event.save
+      flash[:success] = t("clockface.events.create.success")
+      clockface_log(:info, "Created Event: #{event.inspect}")
+      redirect_to clockface.events_path
+    end
+
+    def edit
+      @event = Clockface::Event.find_by_id(params[:id])
+      return if @event
+
+      redirect_to events_path
+      flash[:error] = t("clockface.events.edit.validation.invalid_id")
+    end
+
+    def update
+      event = Clockface::Event.find_by_id(params[:id])
+
+      unless event
+        flash[:error] =
+          t("clockface.events.update.event_not_found", id: params[:id])
+        redirect_to events_path
+        return
+      end
+
+      event.attributes = events_params_for_update
+      validation = validate_event(event)
+
+      if validation.success?
+        event.save
+        flash[:success] = t("clockface.events.update.success")
+        clockface_log(:info, "Updated Event: #{event.inspect}")
+        redirect_to clockface.events_path
+      else
+        flash[:error] = validation.errors
+        redirect_to clockface.edit_event_path(event)
+      end
+    end
+
+    def delete
+      event = Clockface::Event.find_by_id(params[:event_id])
+
+      unless event
+        redirect_to events_path
+        flash[:error] = t("clockface.events.delete.validation.invalid_id")
+        return
+      end
+
+      @event = Clockface::EventsPresenter.new(event)
+      @captcha = captcha_for(event)
+    end
+
+    def destroy
+      event = Clockface::Event.find_by_id(params[:id])
+
+      unless event
+        flash[:error] =
+          t("clockface.events.destroy.event_not_found", id: params[:id])
+        redirect_to events_path
+        return
+      end
+
+      if (params[:captcha] || "") != captcha_for(event)
+        flash[:error] =
+          t("clockface.events.destroy.validation.incorrect_captcha")
+        redirect_to event_delete_path(event)
+        return
+      end
+
+      unless event.destroy
+        flash[:error] = t("clockface.events.destroy.failure")
+        redirect_to event_delete_path(event)
+        return
+      end
+
+      flash[:success] = t("clockface.events.destroy.success")
+      clockface_log(:info, "Destroyed Event: #{event.inspect}")
+      redirect_to events_path
+    end
+
+    private
+
+    def all_events
+      Clockface::Event.includes(:task).order(:id)
+    end
+
+    def events_params_for_create
+      params.require(:event).permit(
+        :clockface_task_id,
+        :name,
+        :enabled,
+        :period_value,
+        :period_units,
+        :day_of_week,
+        :hour,
+        :minute,
+        :time_zone,
+        :if_condition
+      ).tap do |params|
+        params[:hour] = nil if params[:hour] == "**"
+        params[:minute] = nil if params[:minute] == "**"
+      end
+    end
+
+    def events_params_for_update
+      params.require(:event).permit(
+        :name,
+        :enabled,
+        :period_value,
+        :period_units,
+        :day_of_week,
+        :hour,
+        :minute,
+        :time_zone,
+        :if_condition
+      ).tap do |params|
+        params[:hour] = nil if params[:hour] == "**"
+        params[:minute] = nil if params[:minute] == "**"
+      end
+    end
+
+    def validate_event(event)
+      Clockface::EventValidationInteractor.
+        call(event: event, action: params[:action])
+    end
+
+    def captcha_for(event)
+      Digest::SHA1.hexdigest(event.id.to_s).first(CAPTCHA_LENGTH)
+    end
+  end
+end

data/app/controllers/clockface/root_controller.rb

@@ -0,0 +1,7 @@
+module Clockface
+  class RootController < ApplicationController
+    def index
+      redirect_to clockface.events_path
+    end
+  end
+end

data/app/controllers/clockface/tasks_controller.rb

@@ -0,0 +1,137 @@
+module Clockface
+  class TasksController < ApplicationController
+    def index
+      @tasks = all_tasks
+    end
+
+    def new
+    end
+
+    def create
+      task = Clockface::Task.new(tasks_params_for_create)
+      validation = validate_task(task)
+
+      if validation.failure?
+        flash[:error] = validation.errors
+        redirect_to clockface.new_task_path
+        return
+      end
+
+      task.save
+      flash[:success] = t("clockface.tasks.create.success")
+      clockface_log(:info, "Created Task: #{task.inspect}")
+      redirect_to clockface.tasks_path
+    end
+
+    def edit
+      @task = Clockface::Task.find_by_id(params[:id])
+      return if @task
+
+      redirect_to tasks_path
+      flash[:error] = t("clockface.tasks.edit.validation.invalid_id")
+    end
+
+    def update
+      task = Clockface::Task.find_by_id(params[:id])
+
+      unless task
+        flash[:error] =
+          t("clockface.tasks.update.task_not_found", id: params[:id])
+        redirect_to tasks_path
+        return
+      end
+
+      task.attributes = tasks_params_for_update
+      validation = validate_task(task)
+
+      if validation.success?
+        task.save
+        flash[:success] = t("clockface.tasks.update.success")
+        clockface_log(:info, "Updated Task: #{task.inspect}")
+        redirect_to clockface.tasks_path
+      else
+        flash[:error] = validation.errors
+        redirect_to clockface.edit_task_path(task)
+      end
+    end
+
+    def delete
+      @task = Clockface::Task.find_by_id(params[:task_id])
+
+      unless @task
+        redirect_to tasks_path
+        flash[:error] = t("clockface.tasks.delete.validation.invalid_id")
+        return
+      end
+
+      @captcha = captcha_for(@task)
+    end
+
+    def destroy
+      task = Clockface::Task.find_by_id(params[:id])
+
+      unless task
+        flash[:error] =
+          t("clockface.tasks.destroy.task_not_found", id: params[:id])
+        redirect_to tasks_path
+        return
+      end
+
+      # TODO: Move this to interactor
+
+      if (params[:captcha] || "") != captcha_for(task)
+        flash[:error] =
+          t("clockface.tasks.destroy.validation.incorrect_captcha")
+        redirect_to task_delete_path(task)
+        return
+      end
+
+      if task.events.any?
+        flash[:error] =
+          t(
+            "clockface.tasks.destroy.validation.events_exist",
+            count: task.events.count
+          )
+        redirect_to task_delete_path(task)
+        return
+      end
+
+      unless task.destroy
+        flash[:error] = t("clockface.tasks.destroy.failure")
+        redirect_to task_delete_path(task)
+        return
+      end
+
+      flash[:success] = t("clockface.tasks.destroy.success")
+      clockface_log(:info, "Destroyed Task: #{task.inspect}")
+      redirect_to tasks_path
+    end
+
+    private
+
+    def all_tasks
+      Clockface::Task.includes(:events).order(:id)
+    end
+
+    def tasks_params_for_create
+      params.require(:task).permit(
+        :name,
+        :description,
+        :command
+      )
+    end
+
+    def tasks_params_for_update
+      params.require(:task).permit(
+        :name,
+        :description,
+        :command
+      )
+    end
+
+    def validate_task(task)
+      Clockface::TaskValidationInteractor.
+        call(task: task, action: params[:action])
+    end
+  end
+end

data/app/events/clockface/application_job.rb

@@ -0,0 +1,4 @@
+module Clockface
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/helpers/clockface/application_helper.rb

@@ -0,0 +1,4 @@
+module Clockface
+  module ApplicationHelper
+  end
+end

data/app/helpers/clockface/config_helper.rb

@@ -0,0 +1,32 @@
+module Clockface
+  module ConfigHelper
+    def clockface_time_zone
+      tz = Clockface::Engine.config.clockface.time_zone
+      ActiveSupport::TimeZone::MAPPING.key?(tz) ? tz : "UTC"
+    end
+
+    def clockface_tenant_list
+      Clockface::Engine.config.clockface.tenant_list
+    end
+
+    def clockface_single_tenancy_enabled?
+      clockface_tenant_list.empty?
+    end
+
+    def clockface_multi_tenancy_enabled?
+      clockface_tenant_list.any?
+    end
+
+    def clockface_current_tenant
+      Clockface::Engine.config.clockface.current_tenant_proc.call
+    end
+
+    def clockface_execute_in_tenant(tenant_name, some_proc, proc_args = [])
+      Clockface::Engine.config.clockface.execute_in_tenant_proc.call(
+        tenant_name,
+        some_proc,
+        proc_args
+      )
+    end
+  end
+end

data/app/helpers/clockface/events_helper.rb

@@ -0,0 +1,37 @@
+module Clockface
+  module EventsHelper
+    include ConfigHelper
+
+    def event_form_select_options_for_name
+      Clockface::Task.order(:id).collect { |e| [e.name, e.id] }
+    end
+
+    def event_form_select_options_for_period_units
+      Clockface::Event::PERIOD_UNITS.map do |unit|
+        [t("datetime.units.#{unit}"), unit]
+      end
+    end
+
+    def event_form_select_options_for_day_of_week
+      t("date.day_names").each_with_index.map { |day, i| [day, i] }
+    end
+
+    def event_form_select_options_for_hour
+      (["**"] + (0..23).to_a).map { |h| [h.to_s.rjust(2, "0"), h] }
+    end
+
+    def event_form_select_options_for_minute
+      (["**"] + (0..59).to_a).map { |m| [m.to_s.rjust(2, "0"), m] }
+    end
+
+    def event_form_select_options_for_if_condition
+      Clockface::Event::IF_CONDITIONS.keys.map do |if_condition|
+        [
+          Clockface::Event.
+            human_attribute_name("if_condition.#{if_condition}"),
+          if_condition
+        ]
+      end
+    end
+  end
+end

data/app/helpers/clockface/logging_helper.rb

@@ -0,0 +1,12 @@
+module Clockface
+  module LoggingHelper
+    def clockface_log(level, msg)
+      # Clockface logger can be a single `Logger` or an array of many `Logger`s
+      logs = Clockface::Engine.config.clockface.logger
+      logs = [logs] unless logs.is_a?(Array)
+
+      # Log to each individual logger
+      logs.each { |log| log.send(level, "[Clockface] #{msg}") }
+    end
+  end
+end

data/app/mailers/clockface/application_mailer.rb

@@ -0,0 +1,6 @@
+module Clockface
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/clockface/application_record.rb

@@ -0,0 +1,7 @@
+module Clockface
+  class ApplicationRecord < ActiveRecord::Base
+    include Clockface::ConfigHelper
+
+    self.abstract_class = true
+  end
+end

data/app/models/clockface/event.rb

@@ -0,0 +1,179 @@
+module Clockface
+  class Event < ApplicationRecord
+    extend Forwardable
+
+    PERIOD_UNITS = %w[seconds minutes hours days weeks months years].freeze
+    IF_CONDITIONS = {
+      "even_week" => ->(time) { time.strftime("%W").to_i.even? },
+      "odd_week" => ->(time) { time.strftime("%W").to_i.odd? },
+      "weekday" => ->(time) { (time.strftime("%a")[0] != "S") },
+      "first_of_month" => ->(time) { time.strftime("%-d").to_i == 1 },
+      "last_of_month" => ->(time) { (time + 1.day).strftime("%-d").to_i == 1 }
+    }.freeze
+
+    belongs_to(
+      :task,
+      foreign_key: "clockface_task_id",
+      class_name: "Clockface::Task"
+    )
+
+    before_validation do
+      self[:enabled] = false if self[:enabled].nil?
+      self[:time_zone] = clockface_time_zone if self[:time_zone].blank?
+      self[:if_condition] = nil if self[:if_condition].blank?
+      default_tenant_if_needed
+    end
+
+    # rubocop:disable LineLength
+    validates :period_value, presence: true, numericality: { greater_than: 0 }
+    validates :period_units, presence: true, inclusion: PERIOD_UNITS
+    validates :day_of_week, inclusion: { in: 0..6 }, allow_nil: true
+    validates :hour, inclusion: { in: 0..23 }, allow_nil: true
+    validates :minute, inclusion: { in: 0..59 }, allow_nil: true
+    validates :time_zone, inclusion: ActiveSupport::TimeZone::MAPPING.keys, allow_nil: true
+    validates :if_condition, inclusion: IF_CONDITIONS.keys, allow_nil: true
+    # rubocop:enable LineLength
+
+    with_options if: proc { clockface_multi_tenancy_enabled? } do |x|
+      x.validate :tenant_is_valid
+    end
+
+    with_options if: proc { !clockface_multi_tenancy_enabled? } do |x|
+      x.validates :tenant, absence: true
+    end
+
+    validate :day_of_week_must_have_timestamp
+
+    def_delegators(
+      :task,
+      :name,
+      :description,
+      :command
+    )
+
+    def self.find_duplicates_of(event)
+      Clockface::Event.where(
+        period_value: event.period_value,
+        period_units: event.period_units,
+        day_of_week: event.day_of_week,
+        hour: event.hour,
+        minute: event.minute,
+        time_zone: event.time_zone,
+        if_condition: event.if_condition
+      ).where.not(id: event.id)
+    end
+
+    def period
+      # e.g. period_value: 2, period_units: weeks
+      #  => 2.weeks
+      period_value.send(period_units.to_sym)
+    end
+    # Note: Clockwork refers to this value as the period internally, but
+    # `sync_database_events` expects this model to respond to `:frequency`
+    # Keep consistent with internal language by using period, but add alias
+    # for compatibility.
+    # It's also extra confusing since in most fields (e.g. Physics) the words
+    # 'period' and 'frequency' are inverses of each other... oh well.
+    alias frequency period
+
+    def at
+      return nil if self[:hour].nil? && self[:minute].nil?
+
+      [
+        at_formatted_day_of_week,
+        [at_formatted_hour, at_formatted_minute].join(":")
+      ].compact.join(" ")
+    end
+
+    def tz
+      # Active Support stores a mapping between human readable and IANA time
+      # zones. These mappings can be found in `ActiveSupport::TimeZone::MAPPING`
+      #
+      # e.g.
+      #
+      #  "Chennai"    =>  "Asia/Kolkata"
+      #  "Kathmandu"  =>  "Asia/Kathmandu"
+      #  "Tokyo"      =>  "Asia/Tokyo"
+      #
+      # Since multiple human names can point to the same IANA time zone, we
+      # store the human readable name in the underlying `time_zone` DB field
+      #
+      # The Clockwork API dictates that the model must respond to `:tz` and
+      # return the IANA name (See `Clockwork::Event#convert_timezone`), so we
+      # convert the value using ActiveSupport Mapping first
+      #
+      ActiveSupport::TimeZone::MAPPING[self[:time_zone]]
+    end
+
+    def if?(time)
+      if self[:if_condition].present?
+        IF_CONDITIONS[self[:if_condition]].call(time)
+      else
+        true
+      end
+    end
+
+    def if=(if_condition)
+      self[:if_condition] = if_condition
+    end
+
+    def ignored_attributes
+      # Every time Clockwork reloads the models from the database it compares
+      # the before/after attributes to see if the model `has_changed?`. If any
+      # attributes have been changed, it reloads the task.
+      # The Clockwork API lets us selectively ignore some fields in this
+      # attribute comparison.
+      # Exclude `last_triggered_at` and `updated_at` since they will always
+      # change on each run
+      %i[last_triggered_at updated_at]
+    end
+
+    private
+
+    # rubocop:disable Style/GuardClause
+
+    def default_tenant_if_needed
+      if clockface_multi_tenancy_enabled? && self[:tenant].blank?
+        self[:tenant] = clockface_current_tenant
+      end
+    end
+
+    def tenant_is_valid
+      if self[:tenant] != clockface_current_tenant
+        errors.add(
+          :tenant,
+          I18n.t(
+            "activerecord.errors.models.clockface/event."\
+              "attributes.tenant.invalid"
+          )
+        )
+      end
+    end
+
+    def day_of_week_must_have_timestamp
+      if self[:hour].nil? && self[:minute].nil? && !self[:day_of_week].nil?
+        errors.add(
+          :day_of_week,
+          I18n.t(
+            "activerecord.errors.models.clockface/event."\
+              "attributes.day_of_week.day_of_week_must_have_timestamp"
+          )
+        )
+      end
+    end
+
+    # rubocop:enable Style/GuardClause
+
+    def at_formatted_day_of_week
+      Date::DAYNAMES[self[:day_of_week]] if self[:day_of_week].present?
+    end
+
+    def at_formatted_hour
+      self[:hour].present? ? self[:hour].to_s.rjust(2, "0") : "**"
+    end
+
+    def at_formatted_minute
+      self[:minute].present? ? self[:minute].to_s.rjust(2, "0") : "**"
+    end
+  end
+end