sidekiq-scheduler 4.0.2 → 5.0.6

data/lib/sidekiq-scheduler/redis_manager.rb

@@ -9,7 +9,7 @@ module SidekiqScheduler
     #
     # @return [String] schedule in JSON format
     def self.get_job_schedule(name)
-      hget('schedules', name)
+      hget(schedules_key, name)
     end
 
     # Returns the state of a given job
@@ -44,7 +44,7 @@ module SidekiqScheduler
     # @param [String] name The name of the job
     # @param [Hash] config The new schedule for the job
     def self.set_job_schedule(name, config)
-      hset('schedules', name, JSON.generate(config))
+      hset(schedules_key, name, JSON.generate(config))
     end
 
     # Sets the state for a given job
@@ -60,7 +60,7 @@ module SidekiqScheduler
     # @param [String] name The name of the job
     # @param [String] next_time The next time the job has to be executed
     def self.set_job_next_time(name, next_time)
-      hset(next_times_key, name, next_time)
+      hset(next_times_key, name, String(next_time))
     end
 
     # Sets the last execution time for a given job
@@ -68,14 +68,14 @@ module SidekiqScheduler
     # @param [String] name The name of the job
     # @param [String] last_time The last time the job was executed
     def self.set_job_last_time(name, last_time)
-      hset(last_times_key, name, last_time)
+      hset(last_times_key, name, String(last_time))
     end
 
     # Removes the schedule for a given job
     #
     # @param [String] name The name of the job
     def self.remove_job_schedule(name)
-      hdel('schedules', name)
+      hdel(schedules_key, name)
     end
 
     # Removes the next execution time for a given job
@@ -89,14 +89,14 @@ module SidekiqScheduler
     #
     # @return [Hash] hash with all the job schedules
     def self.get_all_schedules
-      Sidekiq.redis { |r| r.hgetall('schedules') }
+      Sidekiq.redis { |r| r.hgetall(schedules_key) }
     end
 
     # Returns boolean value that indicates if the schedules value exists
     #
     # @return [Boolean] true if the schedules key is set, false otherwise
     def self.schedule_exist?
-      Sidekiq.redis { |r| r.exists?('schedules') }
+      SidekiqScheduler::SidekiqAdapter.redis_key_exists?(schedules_key)
     end
 
     # Returns all the schedule changes for a given time range.
@@ -106,22 +106,22 @@ module SidekiqScheduler
     #
     # @return [Array] array with all the changed job names
     def self.get_schedule_changes(from, to)
-      Sidekiq.redis { |r| r.zrangebyscore('schedules_changed', from, "(#{to}") }
+      SidekiqScheduler::SidekiqAdapter.redis_zrangebyscore(schedules_changed_key, from, "(#{to}")
     end
 
     # Register a schedule change for a given job
     #
     # @param [String] name The name of the job
     def self.add_schedule_change(name)
-      Sidekiq.redis { |r| r.zadd('schedules_changed', Time.now.to_f, name) }
+      Sidekiq.redis { |r| r.zadd(schedules_changed_key, Time.now.to_f, name) }
     end
 
     # Remove all the schedule changes records
     def self.clean_schedules_changed
-      Sidekiq.redis { |r| r.del('schedules_changed') unless r.type('schedules_changed') == 'zset' }
+      Sidekiq.redis { |r| r.del(schedules_changed_key) unless r.type(schedules_changed_key) == 'zset' }
     end
 
-    # Removes a queued job instance
+    # Registers a queued job instance
     #
     # @param [String] job_name The name of the job
     # @param [Time] time The time at which the job was cleared by the scheduler
@@ -130,13 +130,13 @@ module SidekiqScheduler
     def self.register_job_instance(job_name, time)
       job_key = pushed_job_key(job_name)
       registered, _ = Sidekiq.redis do |r|
-        r.pipelined do |pipeline|
-          pipeline.zadd(job_key, time.to_i, time.to_i)
-          pipeline.expire(job_key, REGISTERED_JOBS_THRESHOLD_IN_SECONDS)
+        r.multi do |m|
+          m.zadd(job_key, time.to_i, time.to_i)
+          m.expire(job_key, REGISTERED_JOBS_THRESHOLD_IN_SECONDS)
         end
       end
 
-      registered
+      registered.instance_of?(Integer) ? (registered > 0) : registered
     end
 
     # Removes instances of the job older than 24 hours
@@ -156,32 +156,61 @@ module SidekiqScheduler
     #
     # @return [String] the pushed job key
     def self.pushed_job_key(job_name)
-      "sidekiq-scheduler:pushed:#{job_name}"
+      "#{key_prefix}sidekiq-scheduler:pushed:#{job_name}"
     end
 
     # Returns the key of the Redis hash for job's execution times hash
     #
     # @return [String] with the key
     def self.next_times_key
-      'sidekiq-scheduler:next_times'
+      "#{key_prefix}sidekiq-scheduler:next_times"
     end
 
     # Returns the key of the Redis hash for job's last execution times hash
     #
     # @return [String] with the key
     def self.last_times_key
-      'sidekiq-scheduler:last_times'
+      "#{key_prefix}sidekiq-scheduler:last_times"
     end
 
     # Returns the Redis's key for saving schedule states.
     #
     # @return [String] with the key
     def self.schedules_state_key
-      'sidekiq-scheduler:states'
+      "#{key_prefix}sidekiq-scheduler:states"
+    end
+
+    # Returns the Redis's key for saving schedules.
+    #
+    # @return [String] with the key
+    def self.schedules_key
+      "#{key_prefix}schedules"
+    end
+
+    # Returns the Redis's key for saving schedule changes.
+    #
+    # @return [String] with the key
+    def self.schedules_changed_key
+      "#{key_prefix}schedules_changed"
+    end
+
+    # Returns the key prefix used to generate all scheduler keys
+    #
+    # @return [String] with the key prefix
+    def self.key_prefix
+      @key_prefix
+    end
+
+    # Sets the key prefix used to scope all scheduler keys
+    #
+    # @param [String] value The string to use as the prefix. A ":" will be appended as a delimiter if needed.
+    def self.key_prefix=(value)
+      value = "#{value}:" if value && !%w[. :].include?(value[-1])
+      @key_prefix = value
     end
 
     private
-    
+
     # Returns the value of a Redis stored hash field
     #
     # @param [String] hash_key The key name of the hash

data/lib/sidekiq-scheduler/rufus_utils.rb

@@ -3,9 +3,9 @@ require 'sidekiq-scheduler/utils'
 module SidekiqScheduler
   class RufusUtils
 
-    # Normalizes schedule options to rufust scheduler options
+    # Normalizes schedule options to rufus scheduler options
     #
-    # @param options [String, [Array]
+    # @param options [String, Array]
     #
     # @return [Array]
     #

data/lib/sidekiq-scheduler/schedule.rb

@@ -65,7 +65,7 @@ module SidekiqScheduler
     end
     alias_method :schedule!, :reload_schedule!
 
-    # Retrive the schedule configuration for the given name
+    # Retrieve the schedule configuration for the given name
     # if the name is nil it returns a hash with all the
     # names end their schedules.
     def get_schedule(name = nil)
@@ -148,9 +148,7 @@ module SidekiqScheduler
     end
 
     def try_to_constantize(klass)
-      klass.is_a?(String) ? klass.constantize : klass
-    rescue NameError
-      klass
+      SidekiqScheduler::Utils.try_to_constantize(klass)
     end
   end
 end

data/lib/sidekiq-scheduler/scheduler.rb

@@ -2,6 +2,7 @@ require 'rufus/scheduler'
 require 'json'
 require 'sidekiq-scheduler/rufus_utils'
 require 'sidekiq-scheduler/redis_manager'
+require 'sidekiq-scheduler/config'
 
 module SidekiqScheduler
   class Scheduler
@@ -10,6 +11,15 @@ module SidekiqScheduler
       alias_method :params, :opts
     end
 
+    # TODO: Can we remove those attr_accessor's? If we need to keep them, we should
+    # update those values on the config object instead of just here in the scheduler.
+    # That's why we need to do what we do in the set_current_scheduler_options (not
+    # saying we will have to do it somehow still)
+    #
+    # NOTE: ^ Keeping this TODO here for now, in a future version of this project
+    # we will remove those attr accessors and use only our config object. For now,
+    # let's keep as it is.
+
     # Set to enable or disable the scheduler.
     attr_accessor :enabled
 
@@ -41,12 +51,14 @@ module SidekiqScheduler
       end
     end
 
-    def initialize(options = {})
-      self.enabled = options[:enabled]
-      self.dynamic = options[:dynamic]
-      self.dynamic_every = options[:dynamic_every]
-      self.listened_queues_only = options[:listened_queues_only]
-      self.rufus_scheduler_options = options[:rufus_scheduler_options] || {}
+    def initialize(config = SidekiqScheduler::Config.new(without_defaults: true))
+      @scheduler_config = config
+
+      self.enabled = config.enabled?
+      self.dynamic = config.dynamic?
+      self.dynamic_every = config.dynamic_every?
+      self.listened_queues_only = config.listened_queues_only?
+      self.rufus_scheduler_options = config.rufus_scheduler_options || {}
     end
 
     # the Rufus::Scheduler jobs that are scheduled
@@ -82,7 +94,7 @@ module SidekiqScheduler
         Sidekiq.logger.info 'Schedule empty! Set Sidekiq.schedule' if Sidekiq.schedule.empty?
 
         @scheduled_jobs = {}
-        queues = sidekiq_queues
+        queues = scheduler_config.sidekiq_queues
 
         Sidekiq.schedule.each do |name, config|
           if !listened_queues_only || enabled_queue?(config['queue'].to_s, queues)
@@ -116,6 +128,8 @@ module SidekiqScheduler
             schedule, options = SidekiqScheduler::RufusUtils.normalize_schedule_options(config_interval_type)
 
             rufus_job = new_job(name, interval_type, config, schedule, options)
+            return unless rufus_job
+
             @scheduled_jobs[name] = rufus_job
             SidekiqScheduler::Utils.update_job_next_time(name, rufus_job.next_time)
 
@@ -158,7 +172,7 @@ module SidekiqScheduler
       config = prepare_arguments(job_config.dup)
 
       if config.delete('include_metadata')
-        config['args'] = arguments_with_metadata(config['args'], scheduled_at: time.to_f)
+        config['args'] = arguments_with_metadata(config['args'], "scheduled_at" => time.to_f.round(3))
       end
 
       if SidekiqScheduler::Utils.active_job_enqueue?(config['class'])
@@ -182,7 +196,7 @@ module SidekiqScheduler
         @rufus_scheduler = nil
       end
 
-      @@scheduled_jobs = {}
+      @scheduled_jobs = {}
 
       rufus_scheduler
     end
@@ -228,13 +242,37 @@ module SidekiqScheduler
       set_schedule_state(name, state)
     end
 
+    def toggle_all_jobs(new_state)
+      Sidekiq.schedule!.keys.each do |name|
+        state = schedule_state(name)
+        state['enabled'] = new_state
+        set_schedule_state(name, state)
+      end
+    end
+
+    def to_hash
+      {
+        scheduler_config: @scheduler_config.to_hash
+      }
+    end
+
     private
 
+    attr_reader :scheduler_config
+
     def new_job(name, interval_type, config, schedule, options)
       options = options.merge({ :job => true, :tags => [name] })
 
       rufus_scheduler.send(interval_type, schedule, options) do |job, time|
-        idempotent_job_enqueue(name, time, SidekiqScheduler::Utils.sanitize_job_config(config)) if job_enabled?(name)
+        if job_enabled?(name)
+          conf = SidekiqScheduler::Utils.sanitize_job_config(config)
+
+          if job.is_a?(Rufus::Scheduler::CronJob)
+            idempotent_job_enqueue(name, SidekiqScheduler::Utils.calc_cron_run_time(job.cron_line, time.to_t), conf)
+          else
+            idempotent_job_enqueue(name, time.to_t, conf)
+          end
+        end
       end
     end
 
@@ -259,18 +297,18 @@ module SidekiqScheduler
     # Saves a schedule state
     #
     # @param name [String] with the schedule's name
-    # @param name [Hash] with the schedule's state
+    # @param state [Hash] with the schedule's state
     def set_schedule_state(name, state)
       SidekiqScheduler::RedisManager.set_job_state(name, state)
     end
 
     # Adds a Hash with schedule metadata as the last argument to call the worker.
-    # It currently returns the schedule time as a Float number representing the milisencods
+    # It currently returns the schedule time as a Float number representing the milliseconds
     # since epoch.
     #
     # @example with hash argument
-    #   arguments_with_metadata({value: 1}, scheduled_at: Time.now)
-    #   #=> [{value: 1}, {scheduled_at: <miliseconds since epoch>}]
+    #   arguments_with_metadata({value: 1}, scheduled_at: Time.now.round(3))
+    #   #=> [{value: 1}, {scheduled_at: <milliseconds since epoch>}]
     #
     # @param args [Array|Hash]
     # @param metadata [Hash]
@@ -283,14 +321,6 @@ module SidekiqScheduler
       end
     end
 
-    def sidekiq_queues
-      if SIDEKIQ_GTE_6_5_0
-        Sidekiq[:queues].map(&:to_s)
-      else
-        Sidekiq.options[:queues].map(&:to_s)
-      end
-    end
-
     # Returns true if a job's queue is included in the array of queues
     #
     # If queues are empty, returns true.

data/lib/sidekiq-scheduler/sidekiq_adapter.rb

@@ -0,0 +1,91 @@
+module SidekiqScheduler
+  class OptionNotSupportedAnymore < StandardError; end
+
+  class SidekiqAdapter
+    SIDEKIQ_GTE_6_5_0 = Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('6.5.0')
+    SIDEKIQ_GTE_7_0_0 = Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('7.0.0')
+    SIDEKIQ_GTE_7_3_0 = Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('7.3.0')
+
+    def self.fetch_scheduler_config_from_sidekiq(sidekiq_config)
+      return {} if sidekiq_config.nil?
+
+      check_using_old_sidekiq_scheduler_config!(sidekiq_config)
+
+      if SIDEKIQ_GTE_6_5_0
+        sidekiq_config.fetch(:scheduler, {})
+      else
+        sidekiq_config.options.fetch(:scheduler, {})
+      end
+    end
+
+    def self.check_using_old_sidekiq_scheduler_config!(sidekiq_config)
+      %i[enabled dynamic dynamic_every schedule listened_queues_only rufus_scheduler_options].each do |option|
+        if SIDEKIQ_GTE_7_0_0
+          if sidekiq_config.key?(option)
+            raise OptionNotSupportedAnymore, ":#{option} option should be under the :scheduler: key"
+          end
+        elsif SIDEKIQ_GTE_6_5_0
+          unless sidekiq_config[option].nil?
+            raise OptionNotSupportedAnymore, ":#{option} option should be under the :scheduler: key"
+          end
+        else
+          if sidekiq_config.options.key?(option)
+            raise OptionNotSupportedAnymore, ":#{option} option should be under the :scheduler: key"
+          end
+        end
+      end
+    end
+
+    def self.start_schedule_manager(sidekiq_config:, schedule_manager:)
+      if SIDEKIQ_GTE_6_5_0
+        sidekiq_config[:schedule_manager] = schedule_manager
+        sidekiq_config[:schedule_manager].start
+      else
+        sidekiq_config.options[:schedule_manager] = schedule_manager
+        sidekiq_config.options[:schedule_manager].start
+      end
+    end
+
+    def self.stop_schedule_manager(sidekiq_config:)
+      if SIDEKIQ_GTE_6_5_0
+        sidekiq_config[:schedule_manager].stop
+      else
+        sidekiq_config.options[:schedule_manager].stop
+      end
+    end
+
+    def self.sidekiq_queues(sidekiq_config)
+      if SIDEKIQ_GTE_7_0_0
+        if sidekiq_config.nil? || (sidekiq_config.respond_to?(:empty?) && sidekiq_config.empty?)
+          Sidekiq.instance_variable_get(:@config).queues.map(&:to_s)
+        else
+          sidekiq_config.queues.map(&:to_s)
+        end
+      elsif SIDEKIQ_GTE_6_5_0
+        Sidekiq[:queues].map(&:to_s)
+      else
+        Sidekiq.options[:queues].map(&:to_s)
+      end
+    end
+
+    def self.redis_key_exists?(key_name)
+      Sidekiq.redis do |r|
+        if SIDEKIQ_GTE_7_0_0
+          r.exists(key_name) > 0
+        else
+          r.exists?(key_name)
+        end
+      end
+    end
+
+    def self.redis_zrangebyscore(key, from, to)
+      Sidekiq.redis do |r|
+        if SIDEKIQ_GTE_7_0_0
+          r.zrange(key, from, to, "BYSCORE")
+        else
+          r.zrangebyscore(key, from, to)
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq-scheduler/utils.rb

@@ -49,7 +49,7 @@ module SidekiqScheduler
     #
     # @return [Class] the class corresponding to the klass param
     def self.try_to_constantize(klass)
-      klass.is_a?(String) ? klass.constantize : klass
+      klass.is_a?(String) ? Object.const_get(klass) : klass
     rescue NameError
       klass
     end
@@ -57,12 +57,14 @@ module SidekiqScheduler
     # Initializes active_job using the passed parameters.
     #
     # @param [Class] klass The class to initialize
-    # @param [Array/Hash] the parameters passed to the klass initializer
+    # @param [Array, Hash] args The parameters passed to the klass initializer
     #
     # @return [Object] instance of the class klass
-    def self.initialize_active_job(klass, args)
+    def self.initialize_active_job(klass, args, keyword_argument = false)
       if args.is_a?(Array)
         klass.new(*args)
+      elsif args.is_a?(Hash) && keyword_argument
+        klass.new(**symbolize_keys(args))
       else
         klass.new(args)
       end
@@ -71,7 +73,7 @@ module SidekiqScheduler
     # Returns true if the enqueuing needs to be done for an ActiveJob
     #  class false otherwise.
     #
-    # @param [Class] klass the class to check is decendant from ActiveJob
+    # @param [Class] klass the class to check is descendant from ActiveJob
     #
     # @return [Boolean]
     def self.active_job_enqueue?(klass)
@@ -94,7 +96,7 @@ module SidekiqScheduler
         queue: config['queue']
       }.keep_if { |_, v| !v.nil? }
 
-      initialize_active_job(config['class'], config['args']).enqueue(options)
+      initialize_active_job(config['class'], config['args'], config['keyword_argument']).enqueue(options)
     end
 
     # Removes the hash values associated to the rufus metadata keys.
@@ -112,8 +114,10 @@ module SidekiqScheduler
     def self.new_rufus_scheduler(options = {})
       Rufus::Scheduler.new(options).tap do |scheduler|
         scheduler.define_singleton_method(:on_post_trigger) do |job, triggered_time|
-          SidekiqScheduler::Utils.update_job_last_time(job.tags[0], triggered_time)
-          SidekiqScheduler::Utils.update_job_next_time(job.tags[0], job.next_time)
+          if (job_name = job.tags[0])
+            SidekiqScheduler::Utils.update_job_last_time(job_name, triggered_time)
+            SidekiqScheduler::Utils.update_job_next_time(job_name, job.next_time)
+          end
         end
       end
     end
@@ -137,5 +141,41 @@ module SidekiqScheduler
     def self.update_job_last_time(name, last_time)
       SidekiqScheduler::RedisManager.set_job_last_time(name, last_time) if last_time
     end
+
+    # Try to figure out when the cron job was supposed to run.
+    #
+    # Rufus calls the scheduler block with the current time and not the time the block was scheduled to run.
+    # This means under certain conditions you could have a job get scheduled multiple times because `time.to_i` is used
+    # to key the job in redis. If one server is under load and Rufus tries to run the jobs 1 seconds after the other
+    # server then the job will be queued twice.
+    # This method essentially makes a best guess at when this job was supposed to run and return that.
+    #
+    # @param [Fugit::Cron] cron
+    # @param [Time] time
+    #
+    # @return [Time]
+    def self.calc_cron_run_time(cron, time)
+      time = time.floor # remove sub seconds to prevent rounding errors.
+      return time if cron.match?(time) # If the time is a perfect match then return it.
+
+      next_t = cron.next_time(time).to_t
+      previous_t = cron.previous_time(time).to_t
+      # The `time` var is some point between `previous_t` and `next_t`.
+      # Figure out how far off we are from each side in seconds.
+      next_diff = next_t - time
+      previous_diff = time - previous_t
+
+      if next_diff == previous_diff
+        # In the event `time` is exactly between `previous_t` and `next_t` the diff will not be equal to
+        # `cron.rough_frequency`. In that case we round down.
+        cron.rough_frequency == next_diff ? time : previous_t
+      elsif next_diff > previous_diff
+        # We are closer to the previous run time so return that.
+        previous_t
+      else
+        # We are closer to the next run time so return that.
+        next_t
+      end
+    end
   end
 end

data/lib/sidekiq-scheduler/version.rb

@@ -1,3 +1,3 @@
 module SidekiqScheduler
-  VERSION = "4.0.2"
+  VERSION = "5.0.6"
 end

data/lib/sidekiq-scheduler/web.rb

@@ -3,7 +3,7 @@ require 'sidekiq-scheduler'
 require_relative 'job_presenter'
 
 module SidekiqScheduler
-  # Hook into *Sidekiq::Web* Sinatra app which adds a new '/recurring-jobs' page
+  # Hook into *Sidekiq::Web* app which adds a new '/recurring-jobs' page
 
   module Web
     VIEW_PATH = File.expand_path('../../../web/views', __FILE__)
@@ -27,6 +27,11 @@ module SidekiqScheduler
         SidekiqScheduler::Scheduler.instance.toggle_job_enabled(params[:name])
         redirect "#{root_path}recurring-jobs"
       end
+
+      app.post '/recurring-jobs/toggle-all' do
+        SidekiqScheduler::Scheduler.instance.toggle_all_jobs(params[:action] == 'enable')
+        redirect "#{root_path}recurring-jobs"
+      end
     end
   end
 end

data/lib/sidekiq-scheduler.rb

@@ -5,9 +5,9 @@ require_relative 'sidekiq/scheduler'
 require_relative 'sidekiq-scheduler/version'
 require_relative 'sidekiq-scheduler/manager'
 require_relative 'sidekiq-scheduler/redis_manager'
+require_relative 'sidekiq-scheduler/config'
 require_relative 'sidekiq-scheduler/extensions/schedule'
-
-SIDEKIQ_GTE_6_5_0 = Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('6.5.0')
+require_relative 'sidekiq-scheduler/sidekiq_adapter'
 
 Sidekiq.configure_server do |config|
 
@@ -15,25 +15,14 @@ Sidekiq.configure_server do |config|
     # schedules_changed's type was changed from SET to ZSET, so we remove old versions at startup
     SidekiqScheduler::RedisManager.clean_schedules_changed
 
-    # Accessing the raw @config hash through .options is deprecated in 6.5 and to be removed in 7.0
-    config_options = SIDEKIQ_GTE_6_5_0 ? Sidekiq.instance_variable_get(:@config) : config.options
+    scheduler_config = SidekiqScheduler::Config.new(sidekiq_config: config)
 
-    schedule_manager = SidekiqScheduler::Manager.new(config_options)
-    if SIDEKIQ_GTE_6_5_0
-      config[:schedule_manager] = schedule_manager
-      config[:schedule_manager].start
-    else
-      config.options[:schedule_manager] = schedule_manager
-      config.options[:schedule_manager].start
-    end
+    schedule_manager = SidekiqScheduler::Manager.new(scheduler_config)
+    SidekiqScheduler::SidekiqAdapter.start_schedule_manager(sidekiq_config: config, schedule_manager: schedule_manager)
   end
 
   config.on(:quiet) do
-    if SIDEKIQ_GTE_6_5_0
-      config[:schedule_manager].stop
-    else
-      config.options[:schedule_manager].stop
-    end
+    SidekiqScheduler::SidekiqAdapter.stop_schedule_manager(sidekiq_config: config)
   end
 
 end

data/web/assets/{stylesheets → recurring_jobs/stylesheets-scheduler}/recurring_jobs.css

@@ -25,3 +25,18 @@
     border: 1px solid #555;
   }
 }
+
+.toggle-all-buttons {
+  margin-top: 20px;
+  margin-bottom: 10px;
+  line-height: 45px;
+  text-align: right;
+}
+
+@media (max-width: 768px) {
+  .toggle-all-buttons {
+    margin-top: 0;
+    text-align: left;
+    line-height: inherit;
+  }
+}

data/web/locales/cs.yml

@@ -1,4 +1,5 @@
 cs:
+  "Recurring Jobs": Pravidelně opakované
   recurring_jobs: Pravidelně opakované
   name: Jméno
   description: Popis

data/web/locales/de.yml

@@ -1,4 +1,5 @@
 de:
+  "Recurring Jobs": Wiederkehrende Jobs
   recurring_jobs: Wiederkehrende Jobs
   name: Name
   description: Beschreibung
@@ -12,3 +13,5 @@ de:
   no_next_time: Keine zukünftige Ausführung für diesen Job
   disable: Deaktivieren
   enable: Aktivieren
+  disable_all: Alle deaktivieren
+  enable_all: Alle aktivieren

data/web/locales/en.yml

@@ -1,4 +1,5 @@
 en:
+  "Recurring Jobs": Recurring Jobs
   recurring_jobs: Recurring Jobs
   name: Name
   description: Description
@@ -12,3 +13,5 @@ en:
   no_next_time: no next execution for this job
   disable: Disable
   enable: Enable
+  disable_all: Disable all
+  enable_all: Enable all

data/web/locales/es.yml

@@ -1,4 +1,5 @@
 es:
+  "Recurring Jobs": Tareas Recurrentes
   recurring_jobs: Tareas Recurrentes
   name: Nombre
   description: Descripción