effective_polls 0.0.1

data/app/datatables/admin/effective_polls_datatable.rb

@@ -0,0 +1,29 @@
+class Admin::EffectivePollsDatatable < Effective::Datatable
+  filters do
+    scope :upcoming
+    scope :available
+    scope :completed
+    scope :all
+  end
+
+  datatable do
+    order :start_at, :desc
+
+    col :id, visible: false
+    col :created_at, visible: false
+    col :updated_at, visible: false
+
+    col :title
+    col :start_at
+    col :end_at
+    col :audience
+
+    col :poll_questions, visible: false
+
+    actions_col
+  end
+
+  collection do
+    Effective::Poll.all.deep
+  end
+end

data/app/datatables/effective_polls_datatable.rb

@@ -0,0 +1,30 @@
+# Displays available polls that the current_user may complete
+
+class EffectivePollsDatatable < Effective::Datatable
+  datatable do
+    order :start_at
+
+    col :start_at, visible: false
+
+    col :title
+    col :available_date, label: 'Date'
+
+    actions_col(actions: []) do |poll|
+      ballot = poll.ballots.where(user: current_user).first
+
+      if ballot.blank?
+        dropdown_link_to('Start', effective_polls.poll_ballot_build_path(poll, :new, :start))
+      elsif ballot.completed?
+        'Complete'
+      else
+        dropdown_link_to('Continue', effective_polls.poll_ballot_build_path(poll, ballot, ballot.next_step))
+      end
+    end
+  end
+
+  collection do
+    raise('expected a current_user') unless current_user.present?
+    Effective::Poll.available.select { |poll| poll.available_for?(current_user) }
+  end
+
+end

data/app/helpers/effective_polls_helper.rb

@@ -0,0 +1,23 @@
+module EffectivePollsHelper
+
+  # Used by admin/polls form
+  def effective_polls_audience_scope_collection
+    # Normalize the collection into [[label, value], [label, value]]
+    scopes = Array(EffectivePolls.audience_user_scopes).map do |key, value|
+      (key.present? && value.present?) ? [key, value] : [key.to_s.titleize, key]
+    end
+
+    # Makes sure the User model responds to all values
+    scopes.each do |_, scope|
+      unless defined?(User) && User.respond_to?(scope)
+        raise("invalid effective_polls config.audience_user_scopes value. The user model must respond to the scope User.#{scope}")
+      end
+    end
+
+    # Append the number of users in this scope
+    scopes.map! do |label, scope|
+      ["#{label} (#{pluralize(User.send(scope).count, 'user')})", scope]
+    end
+  end
+
+end

data/app/mailers/effective/polls_mailer.rb

@@ -0,0 +1,23 @@
+module Effective
+  class PollsMailer < ActionMailer::Base
+    default from: EffectivePolls.mailer[:default_from]
+    layout EffectivePolls.mailer[:layout].presence || 'effective_polls_mailer_layout'
+
+    def poll_upcoming_reminder(poll_notification, bcc)
+      mail(bcc: bcc, body: poll_notification.body, subject: poll_notification.subject)
+    end
+
+    def poll_start(poll_notification, bcc)
+      mail(bcc: bcc, body: poll_notification.body, subject: poll_notification.subject)
+    end
+
+    def poll_reminder(poll_notification, bcc)
+      mail(bcc: bcc, body: poll_notification.body, subject: poll_notification.subject)
+    end
+
+    def poll_end(poll_notification, bcc)
+      mail(bcc: bcc, body: poll_notification.body, subject: poll_notification.subject)
+    end
+
+  end
+end

data/app/models/effective/access_denied.rb

@@ -0,0 +1,17 @@
+unless defined?(Effective::AccessDenied)
+  module Effective
+    class AccessDenied < StandardError
+      attr_reader :action, :subject
+
+      def initialize(message = nil, action = nil, subject = nil)
+        @message = message
+        @action = action
+        @subject = subject
+      end
+
+      def to_s
+        @message || I18n.t(:'unauthorized.default', :default => 'Access Denied')
+      end
+    end
+  end
+end

data/app/models/effective/ballot.rb

@@ -0,0 +1,73 @@
+module Effective
+  class Ballot < ActiveRecord::Base
+    attr_accessor :current_user
+    attr_accessor :current_step
+
+    belongs_to :poll
+    belongs_to :user
+
+    has_many :ballot_responses, dependent: :destroy
+    accepts_nested_attributes_for :ballot_responses
+
+    acts_as_tokened
+
+    acts_as_wizard(
+      start: 'Start',
+      vote: 'Ballot',
+      submit: 'Review',     # They submit on this step
+      complete: 'Complete'
+    )
+
+    effective_resource do
+      # Acts as tokened
+      token                  :string, permitted: false
+
+      # Acts as Wizard
+      wizard_steps           :text, permitted: false
+
+      # More fields
+      completed_at           :datetime, permitted: false
+
+      current_step           permitted: true
+      timestamps
+    end
+
+    scope :deep, -> { includes(:poll, :user, ballot_responses: [:poll, :poll_question, :poll_question_options]) }
+    scope :sorted, -> { order(:id) }
+    scope :completed, -> { where.not(completed_at: nil) }
+
+    before_validation(if: -> { new_record? }) do
+      self.user ||= current_user
+    end
+
+    validates :user_id, uniqueness: {
+      scope: :poll_id, allow_blank: true, message: 'ballot already exists for this poll'
+    }
+
+    # I seem to need this even tho I accept_nested_attributes
+    validates :ballot_responses, associated: true
+
+    def to_s
+      'ballot'
+    end
+
+    # Find or build
+    def ballot_response(poll_question)
+      ballot_response = ballot_responses.find { |br| br.poll_question_id == poll_question.id }
+      ballot_response ||= ballot_responses.build(poll: poll_question.poll, poll_question: poll_question)
+    end
+
+    # This is the review step where they click Submit Ballot
+    def submit!
+      wizard_steps[:complete] ||= Time.zone.now
+      self.completed_at ||= Time.zone.now
+
+      save!
+    end
+
+    def completed?
+      completed_at.present?
+    end
+
+  end
+end

data/app/models/effective/ballot_response.rb

@@ -0,0 +1,92 @@
+module Effective
+  class BallotResponse < ActiveRecord::Base
+    belongs_to :ballot
+
+    belongs_to :poll
+    belongs_to :poll_question
+
+    has_many :ballot_response_options, dependent: :delete_all
+    has_many :poll_question_options, through: :ballot_response_options
+
+    has_one_attached :upload_file
+
+    effective_resource do
+      # The response
+      date            :date
+      email           :string
+      number          :integer
+      long_answer     :text
+      short_answer    :text
+
+      timestamps
+    end
+
+    scope :completed, -> { where(ballot: Effective::Ballot.completed) }
+    scope :deep, -> { includes(:ballot, :poll, :poll_question, :poll_question_options) }
+
+    validates :poll, presence: true
+    validates :ballot, presence: true
+    validates :poll_question, presence: true
+
+    # Sanity check. These shouldn't happen.
+    validate(if: -> { poll.present? && ballot.present? }) do
+      self.errors.add(:ballot, 'must match poll') unless ballot.poll_id == poll.id
+    end
+
+    validate(if: -> { poll.present? && poll_question.present? }) do
+      self.errors.add(:poll_question, 'must match poll') unless poll_question.poll_id == poll.id
+    end
+
+    validates :date, presence: true, if: -> { poll_question&.required? && poll_question.date? }
+    validates :email, presence: true, email: true, if: -> { poll_question&.required? && poll_question.email? }
+    validates :number, presence: true, if: -> { poll_question&.required? && poll_question.number? }
+    validates :long_answer, presence: true, if: -> { poll_question&.required? && poll_question.long_answer? }
+    validates :short_answer, presence: true, if: -> { poll_question&.required? && poll_question.short_answer? }
+    validates :upload_file, presence: true, if: -> { poll_question&.required? && poll_question.upload_file? }
+    validates :poll_question_option_ids, presence: true, if: -> { poll_question&.required? && poll_question.poll_question_option? }
+
+    validates :poll_question_option_ids, if: -> { poll_question&.choose_one? },
+      length: { maximum: 1, message: 'please choose 1 option only' }
+
+    validates :poll_question_option_ids, if: -> { poll_question&.select_upto_1? },
+      length: { maximum: 1, message: 'please select 1 option or fewer' }
+
+    validates :poll_question_option_ids, if: -> { poll_question&.select_upto_2? },
+      length: { maximum: 2, message: 'please select 2 options or fewer' }
+
+    validates :poll_question_option_ids, if: -> { poll_question&.select_upto_3? },
+      length: { maximum: 3, message: 'please select 3 options or fewer' }
+
+    validates :poll_question_option_ids, if: -> { poll_question&.select_upto_4? },
+      length: { maximum: 4, message: 'please select 4 options or fewer' }
+
+    validates :poll_question_option_ids, if: -> { poll_question&.select_upto_5? },
+      length: { maximum: 5, message: 'please select 5 options or fewer' }
+
+    def to_s
+      'ballot reponse'
+    end
+
+    def response
+      return nil unless poll_question.present?
+
+      return date if poll_question.date?
+      return email if poll_question.email?
+      return number if poll_question.number?
+      return long_answer if poll_question.long_answer?
+      return short_answer if poll_question.short_answer?
+      return upload_file if poll_question.upload_file?
+
+      return poll_question_options.first if poll_question.choose_one?
+      return poll_question_options.first if poll_question.select_upto_1?
+      return poll_question_options if poll_question.poll_question_option?
+
+      raise('unknown response for unexpected poll question category')
+    end
+
+    def category_partial
+      poll_question&.category_partial
+    end
+
+  end
+end

data/app/models/effective/ballot_response_option.rb

@@ -0,0 +1,6 @@
+module Effective
+  class BallotResponseOption < ActiveRecord::Base
+    belongs_to :ballot_response
+    belongs_to :poll_question_option
+  end
+end

data/app/models/effective/poll.rb

@@ -0,0 +1,149 @@
+module Effective
+  class Poll < ActiveRecord::Base
+    attr_accessor :skip_started_validation
+
+    has_rich_text :all_steps_content
+    has_rich_text :start_content
+    has_rich_text :vote_content
+    has_rich_text :submit_content
+    has_rich_text :complete_content
+
+    has_many :poll_notifications, -> { order(:id) }, inverse_of: :poll, dependent: :destroy
+    accepts_nested_attributes_for :poll_notifications, allow_destroy: true
+
+    has_many :poll_questions, -> { order(:position) }, inverse_of: :poll, dependent: :destroy
+    accepts_nested_attributes_for :poll_questions, allow_destroy: true
+
+    has_many :ballots
+    has_many :ballot_responses
+
+    # For the poll_results screens
+    has_many :completed_ballots, -> { Effective::Ballot.completed }, class_name: 'Effective::Ballot'
+    has_many :completed_ballot_responses, -> { where(ballot: Effective::Ballot.completed) }, class_name: 'Effective::BallotResponse'
+
+    acts_as_tokened
+
+    AUDIENCES = ['All Users', 'Individual Users', 'Selected Users']
+
+    effective_resource do
+      # Acts as tokened
+      token                  :string, permitted: false
+
+      title         :string
+
+      start_at      :datetime
+      end_at        :datetime
+
+      audience            :string
+      audience_scope      :text       # An Array of user_ids or named scopes on the User model
+
+      timestamps
+    end
+
+    serialize :audience_scope, Array
+
+    scope :deep, -> {
+      includes(poll_questions: :poll_question_options)
+      .with_rich_text_all_steps_content
+      .with_rich_text_start_content
+      .with_rich_text_vote_content
+      .with_rich_text_submit_content
+      .with_rich_text_complete_content
+    }
+
+    scope :deep_results, -> {
+      includes(poll_questions: :poll_question_options)
+      .includes(ballots: [ballot_responses: [:poll, :poll_question, :poll_question_options]])
+    }
+
+    scope :sorted, -> { order(:start_at) }
+    scope :editable, -> { upcoming }
+
+    scope :upcoming, -> { where('start_at > ?', Time.zone.now) }
+    scope :available, -> { where('start_at <= ? AND (end_at > ? OR end_at IS NULL)', Time.zone.now, Time.zone.now) }
+    scope :completed, -> { where('end_at < ?', Time.zone.now) }
+
+    validates :title, presence: true
+    validates :start_at, presence: true
+
+    validates :audience, inclusion: { in: AUDIENCES }
+    validates :audience_scope, presence: true, unless: -> { audience == 'All Users' }
+
+    validate(if: -> { started? }, unless: -> { skip_started_validation }) do
+      self.errors.add(:base, 'has already started. a poll cannot be changed after it has started.')
+    end
+
+    validate(if: -> { start_at.present? && !started? }, unless: -> { skip_started_validation }) do
+      self.errors.add(:start_at, 'must be a future date') if start_at < Time.zone.now
+    end
+
+    validate(if: -> { start_at.present? && end_at.present? }) do
+      self.errors.add(:end_at, 'must be after the start date') unless end_at > start_at
+    end
+
+    def to_s
+      title.presence || 'New Poll'
+    end
+
+    def available_for?(user)
+      raise('expected a user') unless user.kind_of?(User)
+      available? && users.include?(user)
+    end
+
+    def users
+      case audience
+      when 'All Users'
+        User.all
+      when 'Individual Users'
+        User.where(id: audience_scope)
+      when 'Selected Users'
+        collection = User.none
+        audience_scope.each { |scope| collection = collection.or(User.send(scope)) }
+        collection
+      else
+        raise('unexpected audience')
+      end
+    end
+
+    def emails(exclude_completed: false)
+      if exclude_completed
+        users.where.not(id: completed_ballots.select('user_id as id')).pluck(:email)
+      else
+        users.pluck(:email)
+      end
+    end
+
+    def available?
+      started? && !ended?
+    end
+
+    def started?
+      start_at_was.present? && Time.zone.now >= start_at_was
+    end
+
+    def ended?
+      end_at.present? && end_at < Time.zone.now
+    end
+
+    def available_date
+      if start_at && end_at && start_at.to_date == end_at.to_date
+        "#{start_at.strftime('%F at %H:%M')} to #{end_at.strftime('%H:%M')}"
+      elsif start_at && end_at
+        "#{start_at.strftime('%F at %H:%M')} to #{end_at.strftime('%F %H:%M')}"
+      elsif start_at
+        "#{start_at.strftime('%F at %H:%M')}"
+      end
+    end
+
+    def audience_scope
+      Array(super) - [nil, '']
+    end
+
+    # Returns all completed_ballot_responses
+    def poll_results(poll_question: nil)
+      return completed_ballot_responses if poll_question.nil?
+      completed_ballot_responses.select { |br| br.poll_question_id == poll_question.id }
+    end
+
+  end
+end