effective_cpd 0.0.1

data/app/models/effective/cpd_rule.rb

@@ -0,0 +1,108 @@
+module Effective
+  class CpdRule < ActiveRecord::Base
+    belongs_to :cpd_cycle
+    belongs_to :ruleable, polymorphic: true # Activity or Category
+
+    log_changes(to: :cpd_cycle) if respond_to?(:log_changes)
+
+    # Only permit the words amount, amount2 and any charater 0-9 + - / * ( )
+    INVALID_FORMULA_CHARS = /[^0-9\+\-\/\*\(\)]/
+
+    effective_resource do
+      # A plaintext description of the formula
+      # For a Category: A maximum of 35 PDHs/year may be claimed in the Contributions to Knowledge category
+      # For a Activity: 15 hours of work equals 1 credit
+      credit_description :text
+
+      # The maximum credits per cycle a statement. Nil for no limit
+      max_credits_per_cycle   :integer
+
+      # (amount / 15) or (30) or (amount * 2) or (amount + (amount2 * 10))
+      formula   :string
+
+      # Maximum number of cycles can carry forward
+      max_cycles_can_carry_forward  :integer
+
+      # Cannot be entered in this cycle
+      unavailable     :boolean
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:cpd_cycle, :ruleable) }
+    scope :categories, -> { where(ruleable_type: 'Effective::CpdCategory') }
+    scope :activities, -> { where(ruleable_type: 'Effective::CpdActivity') }
+    scope :unavailable, -> { where(unavailable: true) }
+
+    #validates :cpd_cycle_id, uniqueness: { scope: [:ruleable_id, :ruleable_type] }
+    validates :credit_description, presence: true
+    validates :max_credits_per_cycle, numericality: { greater_than: 0, allow_nil: true }
+    validates :max_cycles_can_carry_forward, numericality: { greater_than: 0, allow_nil: true }
+
+    validates :formula, presence: true, if: -> { activity? }
+    validates :formula, absence: true, if: -> { category? }
+
+    validate(if: -> { formula.present? }) do
+      if formula.gsub('amount2', '').gsub('amount', '').gsub(' ', '').match(INVALID_FORMULA_CHARS).present?
+        self.errors.add(:formula, "may only contain amount, amount2 and 0-9 + - / * ( ) characters")
+      else
+        begin
+          eval_equation(amount: 0, amount2: 0)
+        rescue Exception => e
+          self.errors.add(:formula, e.message)
+        end
+      end
+    end
+
+    # The formula is determined by the cpd_activity's amount_label and amount2_label presence
+    validate(if: -> { formula.present? && activity? }) do
+      amount = formula.gsub('amount2', '').include?('amount')
+      amount2 = formula.include?('amount2')
+
+      cpd_activity = ruleable
+
+      if cpd_activity.amount_label.present? && cpd_activity.amount2_label.present?
+        self.errors.add(:formula, 'must include "amount"') unless amount.present?
+        self.errors.add(:formula, 'must include "amount2"') unless amount2.present?
+      elsif cpd_activity.amount_label.present?
+        self.errors.add(:formula, 'must include "amount"') unless amount.present?
+        self.errors.add(:formula, 'must not include "amount2"') if amount2.present?
+      elsif cpd_activity.amount2_label.present?
+        self.errors.add(:formula, 'must include "amount2"') unless amount2.present?
+        self.errors.add(:formula, 'must not include "amount"') if amount.present?
+      else
+        self.errors.add(:formula, 'must not include "amount"') if amount.present?
+        self.errors.add(:formula, 'must not include "amount2"') if amount2.present?
+      end
+    end
+
+    def to_s
+      formula.presence || 'category'
+    end
+
+    def activity?
+      ruleable.kind_of?(CpdActivity)
+    end
+
+    def category?
+      ruleable.kind_of?(CpdCategory)
+    end
+
+    def score(cpd_statement_activity:)
+      raise('cpd_cycles must match') unless cpd_statement_activity.cpd_statement.cpd_cycle_id == cpd_cycle_id
+      raise('cpd_activities must match') unless cpd_statement_activity.cpd_activity_id == ruleable_id
+
+      return cpd_statement_activity.carry_over if cpd_statement_activity.is_carry_over?
+
+      eval_equation(amount: cpd_statement_activity.amount, amount2: cpd_statement_activity.amount2)
+    end
+
+    private
+
+    def eval_equation(amount: nil, amount2: nil)
+      equation = formula.gsub('amount2', amount2.to_s).gsub('amount', amount.to_s)
+      eval(equation).to_i
+    end
+
+  end
+end

data/app/models/effective/cpd_scorer.rb

@@ -0,0 +1,158 @@
+module Effective
+  class CpdScorer
+    include EffectiveCpdHelper
+
+    def initialize(user:, from: nil)
+      @cycles = CpdCycle.deep.sorted.all
+      @statements = CpdStatement.deep.where(user: user).sorted.all
+
+      if from.present?
+        raise('expected from to be a CpdStatement') unless from.kind_of?(CpdStatement)
+        @statements = @statements.where('cpd_cycle_id >= ?', from.cpd_cycle_id)
+      end
+
+    end
+
+    def score!
+      @statements.each_with_index do |statement, index|
+        prev_statement = @statements[index-1] if index > 0
+
+        Array(prev_statement&.cpd_statement_activities).each do |activity|
+          if activity.marked_for_destruction? # Cascade this down the line
+            statement.cpd_statement_activities.each { |a| a.mark_for_destruction if a.original == activity }
+          end
+
+          if can_carry_forward?(activity, statement.cpd_cycle)
+            save_carry_forward_activity(activity, statement)
+          else
+            delete_carry_forward_activity(activity, statement)
+          end
+        end
+
+        # An activity was deleted from a previous statement
+        statement.cpd_statement_activities.each do |activity|
+          activity.mark_for_destruction if activity.original_id.present? && activity.original.blank?
+        end
+
+        score_statement(statement)
+      end
+
+      save!
+    end
+
+    protected
+
+    def save!
+      CpdStatement.transaction do
+        @statements.each { |statement| statement.save! }; true
+      end
+    end
+
+    def score_statement(statement)
+      cycle = statement.cpd_cycle
+
+      # Reset the current carry_forwards and messages
+      statement.cpd_statement_activities.each do |activity|
+        activity.carry_forward = 0
+        activity.reduced_messages.clear
+      end
+
+      # This scores and enforces CycleActivity.max_credits_per_cycle
+      statement.cpd_statement_activities.group_by(&:cpd_activity).each do |cpd_activity, activities|
+        rule = cycle.rule_for(cpd_activity)
+        max_credits_per_cycle = rule.max_credits_per_cycle || 9999999
+
+        activities.each do |activity|
+          next if activity.marked_for_destruction?
+
+          activity.score = rule.score(cpd_statement_activity: activity)
+          activity.max_score = activity.score # Hack for Category maximums below
+
+          max_credits_per_cycle -= activity.score  # Counting down...
+
+          if max_credits_per_cycle < 0
+            activity.carry_forward = [0 - max_credits_per_cycle, activity.score].min
+            activity.reduced_messages["activity_#{cpd_activity.id}"] = "You have reached the maximum of #{rule.max_credits_per_cycle}/#{cpd_cycle_label} for this type of activity"
+            activity.score = [activity.score + max_credits_per_cycle, 0].max
+          end
+        end
+      end
+
+      # This enforced CycleCategory.max_credits_per_cycle
+      statement.cpd_statement_activities.group_by(&:cpd_category).each do |cpd_category, activities|
+        rule = cycle.rule_for(cpd_category)
+        max_credits_per_cycle = rule.max_credits_per_cycle
+
+        next if max_credits_per_cycle == nil
+
+        activities.each do |activity|
+          next if activity.marked_for_destruction?
+
+          max_credits_per_cycle -= activity.score   # We're already scored. Counting down...
+
+          if max_credits_per_cycle < 0
+            activity.score = [activity.score + max_credits_per_cycle, 0].max
+            activity.carry_forward = activity.max_score - activity.score
+            activity.reduced_messages["category_#{cpd_category.id}"] = "You have reached the maximum of #{rule.max_credits_per_cycle}/#{cpd_cycle_label} for activities in the #{cpd_category} category"
+          end
+        end
+      end
+
+      # This enforces the max_cycles_can_carry_forward logic
+      # If an Activity cannot be carried forward another cycle, its carry_forward should be 0
+      next_cycle = @cycles[@cycles.index(cycle) + 1]
+
+      statement.cpd_statement_activities.each do |activity|
+        next if (activity.carry_forward == 0 || activity.marked_for_destruction?)
+
+        unless can_carry_forward?(activity, next_cycle)
+          activity.carry_forward = 0
+          activity.reduced_messages['max_cycles_can_carry_forward'] = "This activity cannot be carried forward any further"
+        end
+      end
+
+      # Finally set the score from the sum of activitiy scores
+      statement.score = statement.cpd_statement_activities.map { |activity| activity.marked_for_destruction? ? 0 : activity.score }.sum
+    end
+
+    def can_carry_forward?(activity, to_cycle = nil) # This is a StatementActivity being passed
+      return false if (activity.carry_forward == 0 || activity.marked_for_destruction?)
+
+      from_cycle = @cycles.find { |cycle| cycle.id == (activity.original || activity).cpd_statement.cpd_cycle_id }
+      max_cycles_can_carry_forward = from_cycle.rule_for(activity.cpd_activity).max_cycles_can_carry_forward
+
+      return true if max_cycles_can_carry_forward.blank?
+
+      cycles_carried = (@cycles.index(to_cycle) || @cycles.size) - @cycles.index(from_cycle)
+      cycles_carried <= max_cycles_can_carry_forward
+    end
+
+    def save_carry_forward_activity(existing, statement)
+      activity = statement.cpd_statement_activities.find { |a| a.original == (existing.original || existing) }
+      activity ||= statement.cpd_statement_activities.build()
+
+      activity.assign_attributes(
+        cpd_category: existing.cpd_category,
+        cpd_activity: existing.cpd_activity,
+        amount: existing.amount,
+        amount2: existing.amount2,
+        description: existing.description,
+      )
+
+      existing.files.each { |file| activity.files.attach(file.blob) }
+
+      activity.assign_attributes(
+        carry_over: existing.carry_forward,
+        original: existing.original || existing
+      )
+
+      activity
+    end
+
+    def delete_carry_forward_activity(existing, statement)
+      activity = statement.cpd_statement_activities.find { |a| a.original == (existing.original || existing) }
+      activity.mark_for_destruction if activity
+    end
+
+  end
+end

data/app/models/effective/cpd_statement.rb

@@ -0,0 +1,95 @@
+module Effective
+  class CpdStatement < ActiveRecord::Base
+    attr_accessor :current_user
+    attr_accessor :current_step
+
+    belongs_to :cpd_cycle
+    belongs_to :user, polymorphic: true
+
+    has_many :cpd_statement_activities, -> { order(:id) }, inverse_of: :cpd_statement, dependent: :destroy
+    accepts_nested_attributes_for :cpd_statement_activities
+
+    has_many_attached :files
+    log_changes if respond_to?(:log_changes)
+
+    acts_as_tokened
+
+    acts_as_wizard(
+      start: 'Start',
+      activities: 'Enter Activities',
+      agreements: 'Sign Agreements',
+      submit: 'Confirm & Submit',
+      complete: 'Complete'
+    )
+
+    effective_resource do
+      score                   :integer
+
+      confirm_read            :boolean
+      confirm_factual         :boolean
+      confirm_readonly        :boolean
+
+      completed_at           :datetime, permitted: false
+
+      # Acts as tokened
+      token                  :string, permitted: false
+
+      # Acts as Wizard
+      wizard_steps           :text, permitted: false
+      timestamps
+    end
+
+    scope :deep, -> { includes(:cpd_cycle, :user, cpd_statement_activities: [:files_attachments, :cpd_category, :original, cpd_activity: [:rich_text_body]]) }
+    scope :sorted, -> { order(:cpd_cycle_id) }
+
+    scope :draft, -> { where(completed_at: nil) }
+    scope :completed, -> { where.not(completed_at: nil) }
+
+    before_validation(if: -> { new_record? }) do
+      self.user ||= current_user
+      self.score ||= 0
+    end
+
+    validate(if: -> { completed? && cpd_cycle.required_score.present? }) do
+      min = cpd_cycle.required_score
+      self.errors.add(:score, "must be #{min} or greater to submit statement") if score < min
+    end
+
+    with_options(if: -> { current_step == :agreements }) do
+      validates :confirm_read, acceptance: true
+      validates :confirm_factual, acceptance: true
+    end
+
+    with_options(if: -> { current_step == :submit}) do
+      validates :confirm_readonly, acceptance: true
+    end
+
+    def to_s
+      (cpd_cycle || 'statement').to_s
+    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
+
+    def carry_forward
+      cpd_statement_activities.sum { |activity| activity.carry_forward.to_i }
+    end
+
+    # {category_id => 20, category_id => 15}
+    def score_per_category
+      @score_per_category ||= Hash.new(0).tap do |scores|
+        cpd_statement_activities.each { |activity| scores[activity.cpd_category_id] += activity.score.to_i }
+      end
+    end
+
+  end
+end

data/app/models/effective/cpd_statement_activity.rb

@@ -0,0 +1,78 @@
+module Effective
+  class CpdStatementActivity < ActiveRecord::Base
+    attr_accessor :max_score
+
+    belongs_to :cpd_statement
+    belongs_to :cpd_category
+    belongs_to :cpd_activity
+
+    belongs_to :original, class_name: 'CpdStatementActivity', optional: true # If this is a Carryover, the original_statement_activity will be set.
+    #has_many :carried, class_name: 'CpdStatementActivity', foreign_key: 'original_id', dependent: :delete_all
+
+    has_many_attached :files
+
+    if respond_to?(:log_changes)
+      log_changes(to: :cpd_statement)
+    end
+
+    effective_resource do
+      amount            :integer
+      amount2           :integer
+
+      description       :text
+
+      carry_over        :integer    # carry_over_from_last_cycle
+      score             :integer
+      carry_forward     :integer    # carry_forward_to_next_cycle
+
+      reduced_messages  :text
+
+      timestamps
+    end
+
+    serialize :reduced_messages, Hash
+
+    scope :deep, -> { includes(:cpd_statement, :cpd_category, :cpd_activity, :original) }
+    scope :sorted, -> { order(:id) }
+
+    validates :original, presence: true, if: -> { carry_over.to_i > 0 }
+    validates :description, presence: true
+
+    validate(if: -> { cpd_statement.present? }) do
+      self.errors.add(:base, "statement has already been completed") if cpd_statement.completed?
+      self.errors.add(:base, "cycle is unavailable") unless cpd_statement.cpd_cycle.available?
+    end
+
+    def destroy
+      return false if cpd_statement.completed?
+      return false unless cpd_statement.cpd_cycle.available?
+      super
+    end
+
+    def to_s
+      (cpd_activity || 'activity').to_s
+    end
+
+    def reduced_messages
+      self[:reduced_messages] ||= {}
+    end
+
+    def is_carry_over?
+      original.present?
+    end
+
+    def original_cycle
+      (original || self).cpd_statement.cpd_cycle
+    end
+
+    # Will display as read-only on form
+    def locked?
+      is_carry_over? || cpd_statement&.completed?
+    end
+
+    def to_debug
+      "id=#{id}, score=#{score}, carry_foward=#{carry_forward}, carry_from_last=#{carry_over}, original=#{original&.id}"
+    end
+
+  end
+end

data/app/views/admin/cpd_activities/_form.html.haml

@@ -0,0 +1,20 @@
+= effective_form_with(model: [:admin, cpd_activity], engine: true) do |f|
+  - if inline_datatable?
+    = f.hidden_field :cpd_category_id
+  - else
+    = f.select :cpd_category_id, Effective::CpdCategory.sorted.all, label: 'Category'
+
+  .row
+    .col
+      = f.text_field :title, label: 'Title'
+      = f.rich_text_area :body, label: "Body"
+    .col
+      = f.text_field :amount_label,
+        hint: 'hours of work, papers written, courses attended'
+
+      = f.text_field :amount2_label,
+        hint: 'continuing education units'
+
+      = f.check_box :requires_upload_file
+
+  = effective_submit(f)