schedulable 0.0.7 → 0.0.8

data/lib/generators/schedulable/templates/migrations/create_schedules.rb

@@ -9,10 +9,10 @@ class CreateSchedules < ActiveRecord::Migration
       t.string :rule
       t.string :interval
       
-      t.text :days
+      t.text :day
       t.text :day_of_week
       
-      t.date :until
+      t.datetime :until
       t.integer :count
       
       t.timestamps

data/lib/generators/schedulable/templates/models/schedule.rb

@@ -1,13 +1,2 @@
-class Schedule < ActiveRecord::Base
-  
-  include Schedulable::ScheduleSupport
-  
-  serialize :days
-  serialize :day_of_week, Hash
-  
-  belongs_to :schedulable, polymorphic: true
-  
-  after_initialize :init_schedule
-  after_save :init_schedule
-  
+class Schedule < Schedulable::Model::Schedule
 end

data/lib/locales/en.yml

@@ -0,0 +1,29 @@
+en:
+  model:
+    schedule: 'Schedule'
+    
+  activerecord:
+    attributes:
+      schedule:
+        name: Name
+        rule: Regel
+        time: Time
+        date: Date
+        rule: Rule
+        day: Weekdays
+        day_of_week: Weekdays of nth week
+        until: Repeat until
+        count: Repetition count
+        
+  schedulable: 
+    monthly_week_names:
+      1st: '1st'
+      2nd: '2nd'
+      3rd: '3rd'
+      4th: '4th'
+      last: 'Last'
+    rules: 
+      singular: Singular
+      monthly: Monthly
+      weekly: Weekly
+      daily: Daily

data/lib/schedulable.rb

@@ -1,16 +1,18 @@
-require 'schedulable/railtie.rb' if defined? ::Rails::Railtie
-require 'schedulable/acts_as_schedulable.rb'
-require 'schedulable/schedule_support.rb'
+require 'schedulable/railtie' if defined? ::Rails::Railtie
+require 'schedulable/acts_as_schedulable'
+require 'schedulable/schedule'
+require 'schedulable/schedule_support'
+require 'schedulable/form_helper'
 require 'i18n'
 
 module Schedulable
   
   class Config
-    attr_accessor :max_build_count, :max_build_period
+    attr_accessor :max_build_count, :max_build_period, :form_helper, :update_mode
   end
 
   def self.config
-    @@config ||= Config.new
+    @@config||= Config.new
   end
 
   def self.configure

data/lib/schedulable/acts_as_schedulable.rb

@@ -9,9 +9,9 @@ module Schedulable
    
     module ClassMethods
       
-      def acts_as_schedulable(options = {})
+      def acts_as_schedulable(name, options = {})
         
-        name = options[:name] || :schedule
+        name||= :schedule
         attribute = :date
         
         has_one name, as: :schedulable, dependent: :destroy
@@ -37,8 +37,6 @@ module Schedulable
           # table_name
           occurrences_table_name = occurrences_association.to_s.tableize
           
-          puts "SCHEDULABLE OCCURRENCES TABLE NAME: " + occurrences_table_name.to_s
-          
           # remaining
           remaining_occurrences_options = options[:occurrences].clone
           remaining_occurrences_association = ("remaining_" << occurrences_association.to_s).to_sym
@@ -58,7 +56,6 @@ module Schedulable
               # build occurrences for all events
               # TODO: only invalid events
               schedulables = self.all
-              puts "build occurrences for #{schedulables.length} #{self.name.tableize}" 
               schedulables.each do |schedulable| 
                 schedulable.send("build_#{occurrences_association}")
               end
@@ -67,93 +64,103 @@ module Schedulable
         
           define_method "build_#{occurrences_association}" do 
             
+            puts 'build occurrences...'
+            
             # build occurrences for events
             
             schedule = self.send(name)
             
             now = Time.now
-            occurrence_attribute = :date
+            
+            # TODO: Make configurable 
+            occurrence_attribute = :date 
             
             schedulable = schedule.schedulable
-            terminating = schedule.until.present? || schedule.count.present? && schedule.count > 0
-
-            max_build_period = Schedulable.config.max_build_period || 1.year
-            max_date = now + max_build_period
+            terminating = schedule.rule != 'singular' && (schedule.until.present? || schedule.count.present? && schedule.count > 1)
+            
+            max_period = Schedulable.config.max_build_period || 1.year
+            max_date = now + max_period
+            
             max_date = terminating ? [max_date, schedule.last.to_time].min : max_date
             
-            max_build_count = Schedulable.config.max_build_count || 0
-            max_build_count = terminating ? [max_build_count, schedule.remaining_occurrences.count].min : max_build_count
+            max_count = Schedulable.config.max_build_count || 100
+            max_count = terminating && schedule.remaining_occurrences.any? ? [max_count, schedule.remaining_occurrences.count].min : max_count
 
-            # get occurrences
-            if max_build_count > 0
-              # get next occurrences for max_build_count
-              occurrences = schedule.next_occurrences(max_build_count)
-            end
-            
-            if !occurrences || occurrences.last && occurrences.last.to_time > max_date 
-              # get next occurrences for max_date
+            if schedule.rule != 'singular'
+              
+              # Get schedule occurrences
               all_occurrences = schedule.occurrences(max_date)
               occurrences = []
-              # filter future dates
-              all_occurrences.each do |occurrence_date|
-                if occurrence_date.to_time > now
-                  occurrences << occurrence_date
+              # Filter valid dates
+              all_occurrences.each_with_index do |occurrence_date, index|
+                if occurrence_date.present? && occurrence_date.to_time > now
+                  if occurrence_date.to_time < max_date && index < max_count
+                    occurrences << occurrence_date
+                  else
+                    max_date = [max_date, occurrence_date].min
+                  end
                 end
               end
+            
+            else
+              singular_date_time = schedule.date.to_datetime + schedule.time.seconds_since_midnight.seconds
+              occurrences = [singular_date_time]
             end
             
+            # Build occurrences
+            update_mode = Schedulable.config.update_mode || :datetime
             
-            puts 'build occurrences'
+            # Get existing remaining records
+            occurrences_records = schedulable.send("remaining_#{occurrences_association}")
 
             # build occurrences
-            assocs = schedulable.class.reflect_on_all_associations(:has_many)
-            assocs.each do |assoc|
-              puts assoc.name
+            existing_record = nil
+            occurrences.each_with_index do |occurrence, index|
+              
+              # Pull an existing record
+              
+              if update_mode == :index
+                existing_records = [occurrences_records[index]]
+              elsif update_mode == :datetime
+                existing_records = occurrences_records.select { |record|
+                  record.date.to_datetime == occurrence.to_datetime
+                }
+              else
+                existing_records = []
+              end
+
+              if existing_records.any?
+                # Overwrite existing records
+                existing_records.each do |existing_record|
+                  if !occurrences_records.update(existing_record.id, date: occurrence.to_datetime)
+                    puts 'an error occurred while saving an existing occurrence record'
+                  end
+                end
+              else
+                # Create new record
+                if !occurrences_records.create(date: occurrence.to_datetime)
+                  puts 'an error occurred while creating an occurrence record'
+                end
+              end
             end
             
-            occurrences_records = schedulable.send(occurrences_association)
             
-            # clean up unused remaining occurrences 
+            # Clean up unused remaining occurrences 
+            occurrences_records = schedulable.send("remaining_#{occurrences_association}")
             record_count = 0
             occurrences_records.each do |occurrence_record|
               if occurrence_record.date > now
-                # destroy occurrence if it's not used anymore
-                if !schedule.occurs_on?(occurrence_record.date) || occurrence_record.date > max_date || record_count > max_build_count
-                  if occurrences_records.destroy(occurrence_record)
-                    puts 'an error occurred while destroying an unused occurrence record'
-                  end
+                # Destroy occurrence if date or count lies beyond range
+                if schedule.rule != 'singular' && (!schedule.occurs_on?(occurrence_record.date.to_date) || !schedule.occurring_at?(occurrence_record.date.to_time) || occurrence_record.date > max_date) || schedule.rule == 'singular' && record_count > 0
+                  occurrences_records.destroy(occurrence_record)
                 end
                 record_count = record_count + 1
               end
             end
             
-            # build occurrences
-            occurrences.each do |occurrence|
-              
-              # filter existing occurrence records
-              existing = occurrences_records.select { |record|
-                record.date.to_date == occurrence.to_date
-              }
-              if existing.length > 0
-                # a record for this date already exists, adjust time
-                existing.each { |record|
-                  #record.date = occurrence.to_datetime
-                  if !occurrences_records.update(record, date: occurrence.to_datetime)
-                    puts 'an error occurred while saving an existing occurrence record'
-                  end
-                }
-              else
-                # create new record
-                if !occurrences_records.create(date: occurrence.to_datetime)
-                  puts 'an error occurred while creating an occurrence record'
-                end
-              end
-            end
-            
           end
           
         end
-        
       end
   
     end

data/lib/schedulable/form_helper.rb

@@ -0,0 +1,228 @@
+module Schedulable
+  module FormHelper
+    
+    STYLES = {
+      default: {
+        field_html: {class: 'field'},
+        input_wrapper: {tag: 'div'}
+      },
+      bootstrap: {
+        field_html: {class: 'field form-group'},
+        num_field_html: {class: 'form-control'},
+        date_select_html: {class: 'form-control'},
+        date_select_wrapper: {tag: 'div', class: 'form-inline'},
+        collection_select_html: {class: 'form-control'},
+        collection_check_boxes_item_wrapper: {tag: 'span', class: 'checkbox'}
+      }
+    }
+    
+    def self.included(base)
+      ActionView::Helpers::FormBuilder.instance_eval do
+        include FormBuilderMethods
+      end
+    end
+    
+    module FormBuilderMethods
+      
+      def schedule_select(attribute, input_options = {})
+
+        template = @template
+
+        weekdays = Date::DAYNAMES.map(&:downcase)
+        weekdays = weekdays.slice(1..7) << weekdays.slice(0)
+        
+        day_names = I18n.t('date.day_names', default: "")
+        day_names = day_names.blank? ? weekdays.map { |day| day.capitalize } : day_names.slice(1..7) << day_names.slice(0)
+        day_labels = Hash[weekdays.zip(day_names)]
+        
+        # Pass in default month names when missing in translations
+        month_names = I18n.t('date.month_names', default: "")
+        month_names = month_names.blank? ? Date::MONTHNAMES : month_names
+
+        # Pass in default order when missing in translations
+        date_order = I18n.t('date.order', default: [:year, :month, :day])
+        date_order = date_order.map { |order|
+          order.to_sym
+        }
+        
+        date_options = {
+          order: date_order,
+          use_month_names: month_names
+        }
+        
+        # form helper style options
+        
+        config_options = Schedulable.config.form_helper.present? ? Schedulable.config.form_helper : {style: :default}
+        
+        input_options = config_options.merge(input_options)
+        
+        # Setup style options
+        if input_options[:style].is_a?(Symbol) || input_options[:style].is_a?(String)
+          style_options = STYLES.has_key?(input_options[:style]) ? STYLES[input_options[:style]] : STYLES[:default]
+        elsif input_options[:style].is_a?(Hash)
+          style_options = input_options[:style]
+        else
+          style_options = STYLES[:default]
+        end
+        
+        # Merge with general options
+        style_options = style_options.merge(input_options)
+        
+        style_options[:field_html]||= {}
+        
+        style_options[:label_html]||= {}
+        style_options[:label_wrapper]||= {}
+        
+        style_options[:input_html]||= {}
+        style_options[:input_wrapper]||= {}
+        
+        style_options[:number_field_html]||= {}
+        style_options[:number_field_wrapper]||= {}
+        
+        style_options[:date_select_html]||= {}
+        style_options[:date_select_wrapper]||= {}
+        
+        style_options[:collection_select_html]||= {}
+        style_options[:collection_select_wrapper]||= {}
+        
+        style_options[:collection_check_boxes_item_html]||= {}
+        style_options[:collection_check_boxes_item_wrapper]||= {}
+        
+        # Merge with input options
+        style_options[:number_field_html] = style_options[:input_html].merge(style_options[:number_field_html])
+        style_options[:number_field_wrapper] = style_options[:input_wrapper].merge(style_options[:number_field_wrapper])
+        
+        style_options[:date_select_html] = style_options[:input_html].merge(style_options[:date_select_html])
+        style_options[:date_select_wrapper] = style_options[:input_wrapper].merge(style_options[:date_select_wrapper])
+        
+        style_options[:collection_select_html] = style_options[:input_html].merge(style_options[:collection_select_html])
+        style_options[:collection_select_wrapper] = style_options[:input_wrapper].merge(style_options[:collection_select_wrapper])
+        
+        style_options[:collection_check_boxes_item_html] = style_options[:input_html].merge(style_options[:collection_check_boxes_item_html])
+        style_options[:collection_check_boxes_item_wrapper] = style_options[:input_wrapper].merge(style_options[:collection_check_boxes_item_wrapper])
+        
+        
+        # Javascript element id
+        field_id = @object_name.to_s.gsub(/\]\[|[^-a-zA-Z0-9:.]/,"_").sub(/_$/,"") + "_" + attribute.to_s
+
+        @template.content_tag("div", {id: field_id}) do
+          
+          self.fields_for(attribute, @object.send(attribute.to_s) || @object.send("build_" + attribute.to_s)) do |f|
+          
+            @template.content_tag("div", style_options[:field_html]) do
+              select_output = f.collection_select(:rule, ['singular', 'daily', 'weekly', 'monthly'], lambda { |v| return v}, lambda { |v| I18n.t("schedulable.rules.#{v}", default: v.capitalize) }, {include_blank: false}, style_options[:collection_select_html])
+              content_wrap(@template, select_output, style_options[:collection_select_wrapper])
+            end <<
+            
+            @template.content_tag("div", style_options[:field_html].merge({data: {group: 'singular'}})) do
+              content_wrap(@template, f.label(:date, style_options[:label_html]), style_options[:label_wrapper]) <<
+              content_wrap(@template, f.date_select(:date, date_options, style_options[:date_select_html]), style_options[:date_select_wrapper])
+            end << 
+            
+            @template.content_tag("div", style_options[:field_html].merge({data: {group: 'weekly'}})) do
+              content_wrap(@template, f.label(:day), style_options[:label_wrapper]) <<
+              f.collection_check_boxes(:day, weekdays, lambda { |v| return v}, lambda { |v| ("&nbsp;" + day_labels[v]).html_safe}) do |cb|
+                check_box_output = cb.check_box(style_options[:collection_check_boxes_item_html])
+                text = cb.text
+                nested_output = cb.label({}) do |l|
+                  check_box_output + text
+                end
+                content_wrap(@template, nested_output, style_options[:collection_check_boxes_item_wrapper])
+              end
+            end << 
+            
+            @template.content_tag("div", style_options[:field_html].merge({data: {group: 'monthly'}})) do
+              f.fields_for :day_of_week, OpenStruct.new(f.object.day_of_week || {}) do |db|
+                content_wrap(@template, f.label(:day_of_week), style_options[:label_wrapper]) <<
+                @template.content_tag("div", nil, style: 'min-width: 280px; display: table') do
+                  @template.content_tag("div", nil, style: 'display: table-row') do
+                    @template.content_tag("span", nil, style: 'display: table-cell;') <<
+                    ['1st', '2nd', '3rd', '4th', 'last'].reduce(''.html_safe) { | content, item | 
+                      content << @template.content_tag("span", I18n.t("schedulable.monthly_week_names.#{item}", default: item.to_s), style: 'display: table-cell; text-align: center')
+                    }
+                  end <<
+                  weekdays.reduce(''.html_safe) do | content, weekday | 
+                    content << @template.content_tag("div", nil, style: 'display: table-row') do 
+                      @template.content_tag("span", day_labels[weekday] || weekday, style: 'display: table-cell') <<
+                      db.collection_check_boxes(weekday.to_sym, [1, 2, 3, 4, -1], lambda { |i| i} , lambda { |i| "&nbsp;".html_safe}, checked: db.object.send(weekday)) do |cb|
+                        @template.content_tag("span", style: 'display: table-cell; text-align: center') { cb.check_box() }
+                      end 
+                    end
+                  end
+                end
+              end
+            end <<
+            
+            @template.content_tag("div", style_options[:field_html].merge({data: {group: 'singular,daily,weekly,monthly'}})) do
+              content_wrap(@template, f.label(:time, style_options[:label_html]), style_options[:label_wrapper]) <<
+              content_wrap(@template, f.time_select(:time, date_options, style_options[:date_select_html]), style_options[:date_select_wrapper])
+            end <<
+            
+            (if input_options[:interval]
+              @template.content_tag("div", style_options[:field_html].merge({data: {group: 'daily,weekly,monthly'}})) do
+                content_wrap(@template, f.label(:interval, style_options[:label_html]), style_options[:label_wrapper]) <<
+                content_wrap(@template, f.number_field(:interval, style_options[:number_field_html]), style_options[:number_field_wrapper])
+              end
+            else
+              f.hidden_field(:interval, value: 1)
+            end) <<
+            
+            (if input_options[:until]
+              @template.content_tag("div", style_options[:field_html].merge({data: {group: 'daily,weekly,monthly'}})) do
+                content_wrap(@template, f.label(:until, style_options[:label_html]), style_options[:label_wrapper]) <<
+                content_wrap(@template, f.datetime_select(:until, date_options, style_options[:date_select_html]), style_options[:date_select_wrapper])
+              end
+            else
+              f.hidden_field(:until, value: nil)
+            end) <<
+            
+            if input_options[:count]
+              @template.content_tag("div", style_options[:field_html].merge({data: {group: 'daily,weekly,monthly'}})) do
+                content_wrap(@template, f.label(:count, style_options[:label_html]), style_options[:label_wrapper]) <<
+                content_wrap(@template, f.number_field(:count, style_options[:number_field_html]), style_options[:number_field_wrapper])
+              end
+            else
+               f.hidden_field(:count, value: 0)
+            end
+            
+          end
+          
+        end <<
+        
+        template.javascript_tag(
+          "(function() {" << 
+          "  var container = document.querySelectorAll('##{field_id}'); container = container[container.length - 1]; " << 
+          "  var select = container.querySelector(\"select[name*='rule']\"); " << 
+          "  function update() {" <<
+          "    var value = this.value;" << 
+          "    [].slice.call(container.querySelectorAll(\"*[data-group]\")).forEach(function(elem) { " <<
+          "      var groups = elem.getAttribute('data-group').split(',');" <<
+          "      if (groups.indexOf(value) >= 0) {" <<
+          "        elem.style.display = ''" << 
+          "      } else {" <<
+          "        elem.style.display = 'none'" << 
+          "      }" <<
+          "    });" <<
+          "  }" << 
+          "  if (jQuery) { jQuery(select).on('change', update); } else { select.addEventListener('change', update); }" <<
+          "  update.call(select);" << 
+          "})()"
+        )
+        
+      end
+      
+      
+      private 
+        def content_wrap(template, content, options = nil)
+          if options.present? && options.has_key?(:tag)
+            template.content_tag(options[:tag], content, options.except(:tag))
+          else
+            content
+          end  
+        end
+      
+    end
+    
+    
+  end
+end