effective_cpd 0.6.9 → 1.0.0

data/app/models/concerns/effective_cpd_audit_review.rb

@@ -0,0 +1,241 @@
+# EffectiveCpdUser
+#
+# Mark your user model with effective_cpd_user to get a few helpers
+# And user specific point required scores
+
+module EffectiveCpdAuditReview
+  extend ActiveSupport::Concern
+
+  module Base
+    def effective_cpd_audit_review
+      include ::EffectiveCpdAuditReview
+    end
+  end
+
+  module ClassMethods
+    def effective_cpd_audit_review?; true; end
+  end
+
+  included do
+    acts_as_email_form
+    acts_as_tokened
+    acts_as_reportable if respond_to?(:acts_as_reportable)
+    log_changes(to: :cpd_audit, except: :wizard_steps) if respond_to?(:log_changes)
+
+    acts_as_wizard(
+      start: 'Start',
+      information: 'Information',
+      instructions: 'Instructions',
+
+      # Optional based on cpd_audit_level options
+      conflict: 'Conflict of Interest',
+
+      waiting: 'Waiting on Auditee Submission',
+
+      statements: 'Review CPD Statements',
+      # ... There will be one step per cpd_statement here. "statement1"
+
+      questionnaire: 'Review Questionnaire Responses',
+      # ... There will be one step per cpd_audit_level_sections here
+
+      recommendation: 'Recommendation',
+      submit: 'Confirm & Submit',
+      complete: 'Complete'
+    )
+
+    attr_accessor :current_user
+    attr_accessor :current_step
+
+    # App scoped
+    belongs_to :cpd_audit, polymorphic: true
+    belongs_to :cpd_audit_level, polymorphic: true
+
+    belongs_to :user, polymorphic: true    # Auditor
+
+    # Effective scoped
+    has_many :cpd_audit_review_items, -> { Effective::CpdAuditReviewItem.sorted }, class_name: 'Effective::CpdAuditReviewItem', inverse_of: :cpd_audit_review, dependent: :destroy
+    accepts_nested_attributes_for :cpd_audit_review_items, reject_if: :all_blank, allow_destroy: true
+
+    effective_resource do
+      token                     :string
+      due_date                  :date
+
+      # Auditor response
+      conflict_of_interest          :boolean
+      conflict_of_interest_reason   :text
+
+      # Rolling comments
+      comments                  :text
+
+      # Recommendation Step
+      recommendation            :string
+
+      # Status Dates
+      submitted_at              :datetime
+
+      # acts_as_statused
+      # I'm not using acts_as_statused yet, but I probably will later
+      status                  :string
+      status_steps            :text
+
+      # Wizard Progress
+      wizard_steps              :text
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:cpd_audit, :cpd_audit_level, :user) }
+    scope :sorted, -> { order(:id) }
+
+    scope :available, -> { where(submitted_at: nil) }
+    scope :completed, -> { where.not(submitted_at: nil) }
+
+    # effective_reports
+    def reportable_scopes
+      { available: nil, completed: nil }
+    end
+
+    before_validation(if: -> { new_record? }) do
+      self.cpd_audit_level ||= cpd_audit&.cpd_audit_level
+      self.due_date ||= deadline_to_review()
+    end
+
+    validate(if: -> { recommendation.present? }) do
+      unless cpd_audit_level.recommendations.include?(recommendation)
+        self.errors.add(:recommendation, 'must exist in this audit level')
+      end
+    end
+
+    after_commit(on: :create) { send_email(:cpd_audit_review_opened) }
+    after_commit(on: :destroy) { cpd_audit.review! }
+  end
+
+  def to_s
+    persisted? ? "#{cpd_audit_level} Audit Review by #{user}" : 'audit review'
+  end
+
+  # Find or build
+  def cpd_audit_review_item(item)
+    unless item.kind_of?(CpdAuditResponse) || item.kind_of?(CpdStatementActivity)
+      raise("expected a cpd_audit_response or cpd_statement_activity")
+    end
+
+    cpd_audit_review_item = cpd_audit_review_items.find { |cari| cari.item == item }
+    cpd_audit_review_item ||= cpd_audit_review_items.build(item: item)
+  end
+
+  # The dynamic CPD Statement review steps
+  def auditee_cpd_statements
+    cpd_audit.user.cpd_statements.select do |cpd_statement|
+      cpd_statement.completed? && (submitted_at.blank? || cpd_statement.submitted_at < submitted_at)
+    end
+  end
+
+  def cpd_statement(wizard_step)
+    cpd_cycle_id = (wizard_step.to_s.split('statement').last.to_i rescue false)
+    auditee_cpd_statements.find { |cpd_statement| cpd_statement.cpd_cycle_id == cpd_cycle_id }
+  end
+
+  def dynamic_wizard_statement_steps
+    @statement_steps ||= auditee_cpd_statements.each_with_object({}) do |cpd_statement, h|
+      h["statement#{cpd_statement.cpd_cycle_id}".to_sym] = "#{cpd_statement.cpd_cycle.to_s} Activities"
+    end
+  end
+
+  # The dynamic CPD Audit Level Sections steps
+  def cpd_audit_level_section(wizard_step)
+    position = (wizard_step.to_s.split('section').last.to_i rescue false)
+    cpd_audit_level.cpd_audit_level_sections.find { |section| (section.position + 1) == position }
+  end
+
+  def dynamic_wizard_questionnaire_steps
+    @questionnaire_steps ||= cpd_audit_level.cpd_audit_level_sections.each_with_object({}) do |section, h|
+      h["section#{section.position+1}".to_sym] = section.title
+    end
+  end
+
+  def dynamic_wizard_steps
+    dynamic_wizard_statement_steps.merge(dynamic_wizard_questionnaire_steps)
+  end
+
+  def can_visit_step?(step)
+    return (step == :complete) if completed?  # Can only view complete step once submitted
+    can_revisit_completed_steps(step)
+  end
+
+  def required_steps
+    steps = [:start, :information, :instructions]
+
+    steps << :conflict if cpd_audit_level.conflict_of_interest?
+
+    if conflict_of_interest?
+      return steps + [:submit, :complete]
+    end
+
+    steps += [:waiting] unless ready?
+
+    steps += [:statements] + dynamic_wizard_statement_steps.keys
+    steps += [:questionnaire] + dynamic_wizard_questionnaire_steps.keys
+    steps += [:recommendation, :submit, :complete]
+
+    steps
+  end
+
+  def wizard_step_title(step)
+    WIZARD_STEPS[step] || dynamic_wizard_steps.fetch(step)
+  end
+
+  # Called by CpdAudit.extension_granted
+  def extension_granted!
+    self.due_date = deadline_to_review()
+  end
+
+  # Called by CpdAudit.submit!
+  def ready!
+    send_email(:cpd_audit_review_ready)
+  end
+
+  # Called by review wizard submit step
+  def submit!
+    update!(submitted_at: Time.zone.now)
+    cpd_audit.review! # maybe go from submitted->removed
+
+    send_email(:cpd_audit_review_submitted)
+  end
+
+  # When ready, the applicant review wizard hides the waiting step
+  def ready?
+    cpd_audit&.was_submitted?
+  end
+
+  def in_progress?
+    submitted_at.blank?
+  end
+
+  def completed?
+    submitted_at.present?
+  end
+
+  def email_form_defaults(action)
+    { from: EffectiveCpd.mailer_sender }
+  end
+
+  def send_email(email)
+    EffectiveCpd.send_email(email, self, email_form_params) unless email_form_skip?
+    true
+  end
+
+  def deadline_to_conflict_of_interest
+    cpd_audit.deadline_to_conflict_of_interest
+  end
+
+  def deadline_to_review
+    return nil unless cpd_audit_level&.days_to_review.present?
+
+    date = cpd_audit.deadline_to_submit
+    return nil unless date.present?
+
+    EffectiveResources.advance_date(date, business_days: cpd_audit_level.days_to_review)
+  end
+
+end

data/app/models/concerns/effective_cpd_user.rb

@@ -12,6 +12,10 @@ module EffectiveCpdUser
     end
   end
 
+  module ClassMethods
+    def effective_cpd_user?; true; end
+  end
+
   included do
     # App Scoped
     has_many :cpd_statements, -> { order(:cpd_cycle_id) }, inverse_of: :user
@@ -39,18 +43,14 @@ module EffectiveCpdUser
   end
 
   def cpd_statement(cpd_cycle:)
-    raise('expected an Effective::CpdCycle') unless cpd_cycle.class.respond_to?(:effective_cpd_cpd_cycle?)
+    raise('expected an CpdCycle') unless cpd_cycle.class.respond_to?(:effective_cpd_cycle?)
     cpd_statements.find { |cpd_statement| cpd_statement.cpd_cycle_id == cpd_cycle.id }
   end
 
   # Find or build
   def build_cpd_statement(cpd_cycle:)
-    raise('expected an Effective::CpdCycle') unless cpd_cycle.class.respond_to?(:effective_cpd_cpd_cycle?)
+    raise('expected an CpdCycle') unless cpd_cycle.class.respond_to?(:effective_cpd_cycle?)
     cpd_statement(cpd_cycle: cpd_cycle) || cpd_statements.build(cpd_cycle: cpd_cycle)
   end
 
-  module ClassMethods
-    def effective_cpd_user?; true; end
-  end
-
 end

data/app/models/effective/cpd_audit.rb

@@ -1,401 +1,5 @@
 module Effective
   class CpdAudit < ActiveRecord::Base
-    attr_accessor :current_user
-    attr_accessor :current_step
-
-    attr_accessor :admin_process_request
-    ADMIN_PROCESS_REQUEST_OPTIONS = ['Granted', 'Denied']
-
-    belongs_to :cpd_audit_level
-    belongs_to :user, polymorphic: true  # The user being audited
-
-    has_many :cpd_audit_reviews, -> { order(:id) }, inverse_of: :cpd_audit, dependent: :destroy
-    accepts_nested_attributes_for :cpd_audit_reviews, allow_destroy: true
-
-    has_many :cpd_audit_responses, -> { order(:id) }, inverse_of: :cpd_audit, dependent: :destroy
-    accepts_nested_attributes_for :cpd_audit_responses
-
-    has_many_attached :files
-
-    if respond_to?(:log_changes)
-      log_changes(except: [:wizard_steps, :cpd_audit_reviews])
-    end
-
-    acts_as_email_form
-    acts_as_tokened
-    acts_as_reportable if respond_to?(:acts_as_reportable)
-
-    COMPLETED_STATES = [:exemption_granted, :closed]
-
-    WAITING_ON_ADMIN_STATES = [:conflicted, :exemption_requested, :extension_requested, :reviewed]
-    WAITING_ON_REVIEWERS_STATES = [:submitted]
-    WAITING_ON_AUDITEE_STATES = [:opened, :started, :conflicted_resolved, :exemption_denied, :extension_granted, :extension_denied]
-
-    acts_as_statused(
-      :opened,                # Just Opened
-      :started,               # First screen clicked
-      :conflicted,            # Auditee has declared a conflict of interest
-      :conflicted_resolved,   # The conflict of interest has been resolved
-      :exemption_requested,   # Auditee has requested an exemption
-      :exemption_granted,     # Exemption granted -> Audit is cancelled. Exit state.
-      :exemption_denied,      # Exemption denied
-      :extension_requested,   # Audittee has requested an extension
-      :extension_granted,     # Extension granted
-      :extension_denied,      # Extension denied
-      :submitted,             # Audittee has completed questionnaire submitted. Audittee is done.
-      :reviewed,              # All audit reviews completed. Ready for a determination.
-      :closed                 # Determination made by admin and/or audit committee. Exit state. All done.
-    )
-
-    acts_as_wizard(
-      start: 'Start',
-      information: 'Information',
-      instructions: 'Instructions',
-
-      # These 4 steps are determined by audit_level settings
-      conflict: 'Conflict of Interest',
-      exemption: 'Request Exemption',
-      extension: 'Request Extension',
-      waiting: 'Waiting',
-      cpd: 'CPD',
-
-      questionnaire: 'Questionnaire',
-      # ... There will be one step per cpd_audit_level_sections here
-      files: 'Upload Resume',
-
-      submit: 'Confirm & Submit',
-      complete: 'Complete'
-    )
-
-    effective_resource do
-      due_date                 :date     # Computed due date based on notification and extension date
-
-      # Important dates
-      notification_date        :date     # Can be set on CpdAudits#new, but basically created_at
-      extension_date           :date     # set by admin if extension if granted
-
-      # Final determination
-      determination            :string
-
-      # Override Deadlines
-      ignore_deadlines         :boolean
-
-      # Auditee response
-      conflict_of_interest          :boolean
-      conflict_of_interest_reason   :text
-
-      exemption_request             :boolean
-      exemption_request_reason      :text
-
-      extension_request             :boolean
-      extension_request_date        :date
-      extension_request_reason      :text
-
-      # acts_as_statused
-      status                  :string
-      status_steps            :text
-
-      # Status dates
-      started_at              :datetime
-      submitted_at            :datetime
-      reviewed_at             :datetime
-      closed_at               :datetime
-
-      # Acts as tokened
-      token                   :string
-
-      # Acts as Wizard
-      wizard_steps            :text
-
-      timestamps
-    end
-
-    scope :deep, -> { includes(:cpd_audit_level, user: [:cpd_statements], cpd_audit_reviews: [:cpd_audit_level, :user, :cpd_audit_review_items]) }
-    scope :sorted, -> { order(:id) }
-
-    scope :draft, -> { where(submitted_at: nil) }
-    scope :available, -> { where.not(status: COMPLETED_STATES) }
-    scope :completed, -> { where(status: COMPLETED_STATES) }
-
-    scope :waiting_on_admin, -> { where(status: WAITING_ON_ADMIN_STATES) }
-    scope :waiting_on_auditee, -> { where(status: WAITING_ON_AUDITEE_STATES) }
-    scope :waiting_on_reviewers, -> { where(status: WAITING_ON_REVIEWERS_STATES) }
-
-    # effective_reports
-    def reportable_scopes
-      { draft: nil, available: nil, completed: nil, waiting_on_admin: nil, waiting_on_auditee: nil, waiting_on_reviewers: nil }
-    end
-
-    before_validation(if: -> { new_record? }) do
-      self.notification_date ||= Time.zone.now
-      self.due_date ||= deadline_to_submit()
-    end
-
-    validates :notification_date, presence: true
-    validates :determination, presence: true, if: -> { closed? }
-
-    validates :conflict_of_interest_reason, presence: true, if: -> { conflict_of_interest? }
-    validates :exemption_request_reason, presence: true, if: -> { exemption_request? }
-    validates :extension_request_date, presence: true, if: -> { extension_request? }
-    validates :extension_request_reason, presence: true, if: -> { extension_request? }
-
-    validate(if: -> { current_step == :conflict && conflict_of_interest? && !ignore_deadlines? }) do
-      deadline = deadline_to_conflict_of_interest()
-      self.errors.add(:base, 'deadline to declare conflict of interest has already passed') if deadline && deadline < Time.zone.now
-    end
-
-    validate(if: -> { current_step == :exemption && exemption_request? && !ignore_deadlines? }) do
-      deadline = deadline_to_exemption()
-      self.errors.add(:base, 'deadline to request exemption has already passed') if deadline && deadline < Time.zone.now
-    end
-
-    validate(if: -> { current_step == :extension && extension_request? && !ignore_deadlines? }) do
-      deadline = deadline_to_extension()
-      self.errors.add(:base, 'deadline to request extension has already passed') if deadline && deadline < Time.zone.now
-    end
-
-    validate(if: -> { determination.present? }) do
-      unless cpd_audit_level.determinations.include?(determination)
-        self.errors.add(:determination, 'must exist in this audit level')
-      end
-    end
-
-    # If we're submitted. Check if we can go into reviewed?
-    before_save(if: -> { submitted? }) { review! }
-
-    after_commit(on: :create) do
-      send_email(:cpd_audit_opened)
-    end
-
-    def to_s
-      persisted? ? "#{cpd_audit_level} Audit of #{user}" : 'audit'
-    end
-
-    def dynamic_wizard_steps
-      cpd_audit_level.cpd_audit_level_sections.each_with_object({}) do |section, h|
-        h["section#{section.position+1}".to_sym] = section.title
-      end
-    end
-
-    def can_visit_step?(step)
-      return (step == :complete) if was_submitted?  # Can only view complete step once submitted
-      can_revisit_completed_steps(step)
-    end
-
-    def required_steps
-      steps = [:start, :information, :instructions]
-
-      steps << :conflict if cpd_audit_level.conflict_of_interest?
-
-      steps << :exemption if cpd_audit_level.can_request_exemption?
-
-      unless exemption_requested?
-        steps << :extension if cpd_audit_level.can_request_extension?
-      end
-
-      if exemption_requested? || extension_requested?
-        steps += [:waiting]
-      end
-
-      steps += [:cpd, :questionnaire] + dynamic_wizard_steps.keys + [:files, :submit, :complete]
-
-      steps
-    end
-
-    def wizard_step_title(step)
-      WIZARD_STEPS[step] || dynamic_wizard_steps.fetch(step)
-    end
-
-    def deadline_date
-      (extension_date || notification_date)
-    end
-
-    def completed?
-      COMPLETED_STATES.include?(status.to_sym)
-    end
-
-    def in_progress?
-      COMPLETED_STATES.include?(status.to_sym) == false
-    end
-
-    def cpd_audit_level_section(wizard_step)
-      position = (wizard_step.to_s.split('section').last.to_i rescue false)
-      cpd_audit_level.cpd_audit_level_sections.find { |section| (section.position + 1) == position }
-    end
-
-    # Find or build
-    def cpd_audit_response(cpd_audit_level_question)
-      cpd_audit_response = cpd_audit_responses.find { |r| r.cpd_audit_level_question_id == cpd_audit_level_question.id }
-      cpd_audit_response ||= cpd_audit_responses.build(cpd_audit: self, cpd_audit_level_question: cpd_audit_level_question)
-    end
-
-    # Auditee wizard action
-    def start!
-      started!
-    end
-
-    # Admin action
-    def resolve_conflict!
-      wizard_steps[:conflict] = nil   # Have them complete the conflict step again.
-
-      assign_attributes(conflict_of_interest: false, conflict_of_interest_reason: nil)
-      conflicted_resolved!
-      submitted!
-
-      send_email(:cpd_audit_conflict_resolved)
-      true
-    end
-
-    # Auditee wizard action
-    def exemption!
-      return started! unless exemption_request?
-
-      update!(status: :exemption_requested)
-      send_email(:cpd_audit_exemption_request)
-    end
-
-    # Admin action
-    def process_exemption!
-      case admin_process_request
-      when 'Granted' then grant_exemption!
-      when 'Denied' then deny_exemption!
-      else
-        self.errors.add(:admin_process_request, "can't be blank"); save!
-      end
-    end
-
-    def grant_exemption!
-      wizard_steps[:submit] ||= Time.zone.now
-      submitted! && exemption_granted!
-      send_email(:cpd_audit_exemption_granted)
-    end
-
-    def deny_exemption!
-      assign_attributes(exemption_request: false)
-      exemption_denied!
-      send_email(:cpd_audit_exemption_denied)
-    end
-
-    # Auditee wizard action
-    def extension!
-      return started! unless extension_request?
-
-      update!(status: :extension_requested)
-      send_email(:cpd_audit_extension_request)
-    end
-
-    # Admin action
-    def process_extension!
-      case admin_process_request
-      when 'Granted' then grant_extension!
-      when 'Denied' then deny_extension!
-      else
-        self.errors.add(:admin_process_request, "can't be blank"); save!
-      end
-    end
-
-    def grant_extension!
-      self.extension_date = extension_request_date
-      self.due_date = deadline_to_submit()
-
-      cpd_audit_reviews.each { |cpd_audit_review| cpd_audit_review.extension_granted! }
-      extension_granted!
-      send_email(:cpd_audit_extension_granted)
-    end
-
-    def deny_extension!
-      assign_attributes(extension_request: false)
-      extension_denied!
-      send_email(:cpd_audit_extension_denied)
-    end
-
-    # Require CPD step
-    def user_cpd_required?
-      return false unless user.cpd_audit_cpd_required?
-      required_cpd_cycle.present?
-    end
-
-    def user_cpd_completed?
-      return true if required_cpd_cycle.blank?
-      user.cpd_statements.any? { |s| s.completed? && s.cpd_cycle_id == required_cpd_cycle.id }
-    end
-
-    def required_cpd_cycle
-      @required_cpd_cycle ||= begin
-        last_year = ((notification_date || created_at || Time.zone.now) - 1.year).all_year
-        Effective::CpdCycle.available.where(start_at: last_year).first
-      end
-    end
-
-    # Auditee wizard action
-    def submit!
-      if conflict_of_interest?
-        conflicted!
-        send_email(:cpd_audit_conflicted)
-      else
-        submitted!
-
-        cpd_audit_reviews.each { |cpd_audit_review| cpd_audit_review.ready! }
-        send_email(:cpd_audit_submitted)
-      end
-
-      true
-    end
-
-    # Called in a before_save. Intended for applicant_review to call in its submit! method
-    def review!
-      return false unless submitted?
-      return false unless cpd_audit_reviews.present? && cpd_audit_reviews.all?(&:completed?)
-
-      reviewed!
-      send_email(:cpd_audit_reviewed)
-    end
-
-    # Admin action
-    def close!
-      closed!
-      send_email(:cpd_audit_closed)
-    end
-
-    def email_form_defaults(action)
-      { from: EffectiveCpd.mailer_sender }
-    end
-
-    def send_email(email)
-      EffectiveCpd.send_email(email, self, email_form_params) unless email_form_skip?
-      true
-    end
-
-    def deadline_to_conflict_of_interest
-      return nil unless cpd_audit_level&.conflict_of_interest?
-      return nil unless cpd_audit_level.days_to_declare_conflict.present?
-
-      date = (notification_date || created_at || Time.zone.now)
-      EffectiveResources.advance_date(date, business_days: cpd_audit_level.days_to_declare_conflict)
-    end
-
-    def deadline_to_exemption
-      return nil unless cpd_audit_level&.can_request_exemption?
-      return nil unless cpd_audit_level.days_to_request_exemption.present?
-
-      date = (notification_date || created_at || Time.zone.now)
-      EffectiveResources.advance_date(date, business_days: cpd_audit_level.days_to_request_exemption)
-    end
-
-    def deadline_to_extension
-      return nil unless cpd_audit_level&.can_request_extension?
-      return nil unless cpd_audit_level.days_to_request_extension.present?
-
-      date = (notification_date || created_at || Time.zone.now)
-      EffectiveResources.advance_date(date, business_days: cpd_audit_level.days_to_request_extension)
-    end
-
-    def deadline_to_submit
-      return nil unless cpd_audit_level&.days_to_submit.present?
-
-      date = (extension_date || notification_date || created_at || Time.zone.now)
-      EffectiveResources.advance_date(date, business_days: cpd_audit_level.days_to_submit)
-    end
-
+    effective_cpd_audit
   end
 end