concerto_template_scheduling 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 19a1b3329508cae93b9159a4f5a799a5cc657305
+  data.tar.gz: dfcd729f0c7eef50ef11cbbba06252a8e09ce1fa
+SHA512:
+  metadata.gz: bc389fe4c6c5dd23fe2c840bfd09d8f81865d39ec2547db3ac2f575f398aeecdd8f47011f5ebfe7aaeafa53190c5fc8dac55fd1f8e023927a5f55bfe4b4bf851
+  data.tar.gz: 8cc002b04ee118f3f66b2902ddcfdfa96e6cc0ef21c0d8910b0d3f4313fe270c4a12b43fc2b10f1c9f85a00e8835272279e84605a4a91792dae12a95f2ff57f6

data/LICENSE

@@ -0,0 +1,13 @@
+  Copyright 2014 Concerto Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,24 @@
+# Concerto Template Scheduling
+
+A Rails Engine for scheduling templates for your screens in Concerto.
+
+Templates can be scheduled for a specific time frame for specific days.  A template will be made active when this 
+scheduling criteria is met.  A template can also be made active when content exists on a specified feed-- such as when 
+you want travel advisories or weather alerts to show at the bottom of your screen while still having your other content
+shown.
+
+To use this engine, add the following to the Concerto Gemfile: 
+```
+gem 'concerto_template_scheduling'
+```
+
+To create the proper migrations, run: 
+```
+rails generate concerto_template_scheduling
+```
+
+## Security
+If a user can update a screen, they have the ability to manage the scheduled templates for that screen.
+
+## Requirements
+`start_time` and `end_time` setters (in the model) don't work well with ruby 1.8.7.

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ConcertoTemplateScheduling'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/javascripts/concerto_template_scheduling/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/javascripts/concerto_template_scheduling/schedules.js

@@ -0,0 +1,25 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.
+
+function attachConcertoTemplateSchedulingHandlers() {
+  $('select#schedule_config_display_when').on('change', toggleCtsFormFields);
+
+  function toggleCtsFormFields() {
+    var dw = $('select#schedule_config_display_when').val();
+    if (dw == 3) {  // 'content exists'
+      $('#feed_selection').show();
+      $('#scheduling_criteria').hide();
+    } else if (dw == 2) {  // 'by criteria'
+      $('#feed_selection').hide();
+      $('#scheduling_criteria').show();
+    } else {
+      $('#feed_selection').hide();
+      $('#scheduling_criteria').hide();
+    }
+  }
+
+  toggleCtsFormFields();
+}
+
+$(document).ready(attachConcertoTemplateSchedulingHandlers);
+$(document).on('page:change', attachConcertoTemplateSchedulingHandlers);

data/app/assets/stylesheets/concerto_template_scheduling/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

data/app/assets/stylesheets/concerto_template_scheduling/schedules.css

@@ -0,0 +1,4 @@
+/*
+  Place all the styles related to the matching controller here.
+  They will automatically be included in application.css.
+*/

data/app/assets/stylesheets/scaffold.css

@@ -0,0 +1,56 @@
+body { background-color: #fff; color: #333; }
+
+body, p, ol, ul, td {
+  font-family: verdana, arial, helvetica, sans-serif;
+  font-size:   13px;
+  line-height: 18px;
+}
+
+pre {
+  background-color: #eee;
+  padding: 10px;
+  font-size: 11px;
+}
+
+a { color: #000; }
+a:visited { color: #666; }
+a:hover { color: #fff; background-color:#000; }
+
+div.field, div.actions {
+  margin-bottom: 10px;
+}
+
+#notice {
+  color: green;
+}
+
+.field_with_errors {
+  padding: 2px;
+  background-color: red;
+  display: table;
+}
+
+#error_explanation {
+  width: 450px;
+  border: 2px solid red;
+  padding: 7px;
+  padding-bottom: 0;
+  margin-bottom: 20px;
+  background-color: #f0f0f0;
+}
+
+#error_explanation h2 {
+  text-align: left;
+  font-weight: bold;
+  padding: 5px 5px 5px 15px;
+  font-size: 12px;
+  margin: -7px;
+  margin-bottom: 0px;
+  background-color: #c00;
+  color: #fff;
+}
+
+#error_explanation ul li {
+  font-size: 12px;
+  list-style: square;
+}

data/app/controllers/concerto_template_scheduling/application_controller.rb

@@ -0,0 +1,4 @@
+module ConcertoTemplateScheduling
+  class ApplicationController < ::ApplicationController
+  end
+end

data/app/controllers/concerto_template_scheduling/schedules_controller.rb

@@ -0,0 +1,106 @@
+require_dependency "concerto_template_scheduling/application_controller"
+
+module ConcertoTemplateScheduling
+  class SchedulesController < ApplicationController
+    # since scheduled templates are basically an extended feature of a screen
+    # if the user can update the screen then they can crud scheduled templates
+
+    # GET /schedules
+    # GET /schedules.json
+    def index
+      @schedules = Schedule.all
+      # ignore the schedules that belong to screens we cant read
+      # or schedules where the template has been deleted
+      @schedules.reject! { |s| !can?(:read, s.screen) || s.template.nil? }
+  
+      respond_to do |format|
+        format.html # index.html.erb
+        format.json { render json: @schedules }
+      end
+    end
+  
+    # GET /schedules/1
+    # GET /schedules/1.json
+    def show
+      @schedule = Schedule.find(params[:id])
+      auth! :action => :read, :object => @schedule.screen
+
+      respond_to do |format|
+        format.html # show.html.erb
+        format.json { render json: @schedule }
+      end
+    end
+  
+    # GET /schedules/new
+    # GET /schedules/new.json
+    def new
+      @schedule = Schedule.new
+      if !params[:screen_id].nil?
+        # TODO: Error handling
+        @schedule.screen = Screen.find(params[:screen_id])
+      end
+      auth! :action => :update, :object => @schedule.screen
+
+      respond_to do |format|
+        format.html # new.html.erb
+        format.json { render json: @schedule }
+      end
+    end
+  
+    # GET /schedules/1/edit
+    def edit
+      @schedule = Schedule.find(params[:id])
+      auth! :action => :update, :object => @schedule.screen
+    end
+  
+    # POST /schedules
+    # POST /schedules.json
+    def create
+      @schedule = Schedule.new(schedule_params)
+      auth! :action => :update, :object => @schedule.screen
+      respond_to do |format|
+        if @schedule.save
+          format.html { redirect_to @schedule, notice: 'Schedule was successfully created.' }
+          format.json { render json: @schedule, status: :created, location: @schedule }
+        else
+          format.html { render action: "new" }
+          format.json { render json: @schedule.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+  
+    # PUT /schedules/1
+    # PUT /schedules/1.json
+    def update
+      @schedule = Schedule.find(params[:id])
+      auth! :action => :update, :object => @schedule.screen
+
+      respond_to do |format|
+        if @schedule.update_attributes(schedule_params)
+          format.html { redirect_to @schedule, notice: 'Schedule was successfully updated.' }
+          format.json { head :no_content }
+        else
+          format.html { render action: "edit" }
+          format.json { render json: @schedule.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+  
+    # DELETE /schedules/1
+    # DELETE /schedules/1.json
+    def destroy
+      @schedule = Schedule.find(params[:id])
+      auth! :action => :update, :object => @schedule.screen
+      @schedule.destroy
+  
+      respond_to do |format|
+        format.html { redirect_to schedules_url }
+        format.json { head :no_content }
+      end
+    end
+
+    def schedule_params
+      params.require(:schedule).permit(*ConcertoTemplateScheduling::Schedule.form_attributes)
+    end
+  end
+end

data/app/helpers/concerto_template_scheduling/application_helper.rb

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

data/app/helpers/concerto_template_scheduling/schedules_helper.rb

@@ -0,0 +1,4 @@
+module ConcertoTemplateScheduling
+  module SchedulesHelper
+  end
+end

data/app/models/concerto_template_scheduling/schedule.rb

@@ -0,0 +1,181 @@
+module ConcertoTemplateScheduling
+  class Schedule < ActiveRecord::Base
+    include ActiveModel::ForbiddenAttributesProtection
+
+    DISPLAY_NEVER=0
+    DISPLAY_ALWAYS=1
+    DISPLAY_AS_SCHEDULED=2
+    DISPLAY_CONTENT_EXISTS=3
+
+    DISPLAY_WHEN = {
+      I18n.t('concerto_template_scheduling.never') => DISPLAY_NEVER, 
+      I18n.t('concerto_template_scheduling.always') => DISPLAY_ALWAYS, 
+      I18n.t('concerto_template_scheduling.as_scheduled') => DISPLAY_AS_SCHEDULED,
+      I18n.t('concerto_template_scheduling.content_exists') => DISPLAY_CONTENT_EXISTS
+    }
+
+    belongs_to :screen
+    belongs_to :template
+    
+    attr_accessor :config
+
+    after_initialize :create_config
+    after_find :load_config
+    before_validation :save_config
+
+    validates_associated :screen
+    validates_presence_of :screen, :message => I18n.t('concerto_template_scheduling.must_be_selected')
+    # do not require uniqueness because the same template may be scheduled
+    # for different time frames with different occurrence criteria
+    # validates_uniqueness_of :template_id, :scope => :screen_id
+
+    validates_associated :template
+    validates_presence_of :template, :message => I18n.t('concerto_template_scheduling.must_be_selected')
+
+    validate :from_time_must_precede_to_time
+    validate :schedule_must_be_defined
+
+    def from_time_must_precede_to_time
+      if Time.zone.parse(self.config['from_time']) > Time.zone.parse(self.config['to_time'])
+        errors.add(:base, I18n.t('concerto_template_scheduling.from_time_must_precede_to_time'))
+      end
+    end
+
+    def schedule_must_be_defined
+      if self.config['display_when'].to_i == DISPLAY_AS_SCHEDULED
+        if self.config['scheduling_criteria'].empty?
+          errors.add(:base, I18n.t('concerto_template_scheduling.schedule_must_be_defined'))
+        end
+      end
+    end
+
+    def self.active
+      where("start_time < :now AND end_time > :now", {:now => Clock.time})
+    end
+
+    def self.form_attributes
+      attributes = [:screen_id, :template_id,  
+        {:start_time => [:time, :date]}, {:end_time => [:time, :date]}, 
+        {:config => [:display_when, :from_time, :to_time, :feed_id, :scheduling_criteria]}]
+    end
+
+    # Specify the default configuration hash.
+    # This will be used if a configuration doesn't exist.
+    #
+    # @return [Hash{String => String, Number}] configuration hash.
+    def default_config
+      {
+        'display_when' => DISPLAY_ALWAYS,
+        'from_time' => '12:00am',
+        'to_time' => '11:59pm'
+      }
+    end
+
+    # Create a new configuration hash if one does not already exist.
+    # Called during `after_initialize`, where a config may or may not exist.
+    def create_config
+      self.start_time ||= Time.zone.parse("12:00am", Clock.time + ConcertoConfig[:start_date_offset].to_i.days)
+      self.end_time ||= Time.zone.parse("11:59pm", Clock.time + ConcertoConfig[:start_date_offset].to_i.days + ConcertoConfig[:default_content_run_time].to_i.days)
+
+      self.config = {} if !self.config
+      self.config = default_config().merge(self.config)
+      self.config
+    end
+
+    # Load a configuration hash.
+    # Converts the JSON data stored for the schedule into the configuration.
+    # Called during `after_find`.
+    def load_config
+      self.config = JSON.load(self.data)
+    end
+
+    # Prepare the configuration to be saved.
+    # Compress the config hash back into JSON to be stored in the database.
+    # Called during `before_validation`.
+    def save_config
+      self.config['scheduling_criteria'] = '' if self.config['scheduling_criteria'] == 'null'
+      self.data = JSON.dump(self.config)
+    end
+
+# TODO: make sure these formats are locale-ized!
+
+    # Setter for the start time.  If a hash is passed, convert that into a DateTime object and then a string.
+    # Otherwise, just set it like normal.  This is a bit confusing due to the differences in how Ruby handles
+    # times between 1.9.x and 1.8.x.
+    def start_time=(_start_time)
+      if _start_time.kind_of?(Hash)
+        #write_attribute(:start_time, Time.parse("#{_start_time[:date]} #{_start_time[:time]}").to_s(:db))
+        # convert to time, strip off the timezone offset so it reflects local time
+        t = DateTime.strptime("#{_start_time[:date]} #{_start_time[:time]}", "%m/%d/%Y %l:%M %p")
+        write_attribute(:start_time, Time.zone.parse(t.utc.iso8601.slice(0, 19)).to_s(:db))
+      else
+        write_attribute(:start_time, _start_time)
+      end
+    end
+
+    # See start_time=.
+    def end_time=(_end_time)
+      if _end_time.kind_of?(Hash)
+        # convert to time, strip off the timezone offset so it reflects local time
+        t = DateTime.strptime("#{_end_time[:date]} #{_end_time[:time]}", "%m/%d/%Y %l:%M %p")
+        write_attribute(:end_time, Time.zone.parse(t.utc.iso8601.slice(0, 19)).to_s(:db))
+      else
+        write_attribute(:end_time, _end_time)
+      end
+    end
+
+    def schedule_in_words
+      if !self.config['scheduling_criteria'].empty?
+        s = IceCube::Schedule.new(self.start_time)
+        s.add_recurrence_rule(RecurringSelect.dirty_hash_to_rule(self.config['scheduling_criteria']))
+        s.to_s
+      end
+    end
+
+    def is_effective?
+      effective = false
+
+      # if it is during the valid/active time frame and the template still exists
+      if Clock.time >= self.start_time && Clock.time <= self.end_time && !self.template.nil?
+        # and it is within the viewing window for the day
+        if Clock.time >= Time.parse(self.config['from_time']) && Clock.time <= Time.parse(self.config['to_time'])
+          # and it is either marked as always shown
+          if self.config['display_when'].to_i == DISPLAY_ALWAYS
+            effective = true
+          elsif self.config['display_when'].to_i == DISPLAY_CONTENT_EXISTS
+            # or if we detect actual content on the specified feed
+            if !self.feed.nil? && !self.feed.approved_contents.active.where('kind_id != 4').empty?
+              effective = true
+            end
+          elsif self.config['display_when'].to_i == DISPLAY_AS_SCHEDULED
+            if !self.config['scheduling_criteria'].empty?
+              s = IceCube::Schedule.new(self.start_time)
+              s.add_recurrence_rule(RecurringSelect.dirty_hash_to_rule(self.config['scheduling_criteria']))
+              effective = s.occurs_on? Clock.time
+            else
+              # no schedule was set
+            end
+          end
+        end
+      end
+
+      effective
+    end
+
+    def feed
+      if self.config.include?('feed_id')
+        f = Feed.find(self.config['feed_id'].to_i)
+      end
+      f
+    end
+
+    def selectable_feeds
+      if !self.screen.nil?
+        feeds = Feed.all
+        ability = Ability.new(self.screen)
+        feeds.reject { |feed| !ability.can?(:read, feed) }
+      end
+    end
+
+  end
+end