effective_memberships 0.1.2

data/app/models/concerns/effective_memberships_applicant_review.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+# EffectiveMembershipsApplicantReview
+#
+# Mark your category model with effective_memberships_applicant_review to get all the includes
+
+module EffectiveMembershipsApplicantReview
+  extend ActiveSupport::Concern
+
+  module Base
+    def effective_memberships_applicant_review
+      include ::EffectiveMembershipsApplicantReview
+    end
+  end
+
+  module ClassMethods
+    def effective_memberships_applicant_review?; true; end
+
+    def all_wizard_steps
+      const_get(:WIZARD_STEPS).keys
+    end
+
+    # For effective_category_applicant_wizard_steps_collection
+    def required_wizard_steps
+      [:start, :recommendation, :submitted]
+    end
+
+    def recommendations
+      ['Accept', 'Reject']
+    end
+
+  end
+
+  included do
+    log_changes if respond_to?(:log_changes)
+
+    acts_as_tokened
+
+    acts_as_statused(
+      :draft,         # Just Started
+      :conflicted,    # Conflict of Interest
+      :accepted,      # Accepted
+      :rejected       # Rejected
+    )
+
+    acts_as_wizard(
+      start: 'Start',
+      conflict: 'Conflict of Interest',
+      education: 'Education',
+      course_amounts: 'Courses',
+      experience: 'Work Experience',
+      references: 'References',
+      files: 'Attach Files',
+      declarations: 'Declarations',
+      recommendation: 'Recommendation',
+      submitted: 'Submitted'
+    )
+
+    belongs_to :applicant
+    belongs_to :reviewer, polymorphic: true
+
+    effective_resource do
+      submitted_at              :datetime
+      recommendation            :string
+
+      comments                  :text         # Rolling comments
+
+      # Conflict Step
+      conflict_of_interest      :boolean
+
+      # Education Step
+      education_accepted        :boolean
+
+      # Course Amounts
+      course_amounts_accepted   :boolean
+
+      # Courses
+      courses_accepted          :boolean
+
+      # Experience Step
+      experience_accepted       :boolean
+
+      # References Step
+      references_accepted       :boolean
+
+      # References Step
+      files_accepted            :boolean
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:reviewer, applicant: :owner) }
+
+    with_options(if: -> { current_step == :conflict }) do
+      validates :conflict_of_interest, inclusion: { in: [true, false] }
+      validates :comments, presence: true, if: -> { conflict_of_interest? }
+    end
+
+    validates :recommendation, absence: true, if: -> { done? && conflict_of_interest? }
+
+    after_commit(on: :create, if: -> { applicant.completed? }) { notify! }
+
+    def to_s
+      'applicant review'
+    end
+
+    def in_progress?
+      draft?
+    end
+
+    def done?
+      !draft?
+    end
+
+    def conflict_of_interest!
+      after_commit { send_email(:applicant_review_conflict_of_interest) }
+
+      update!(conflict_of_interest: true, recommendation: nil)
+      conflicted!
+
+      applicant.save!
+    end
+
+    def accept!
+      after_commit { send_email(:applicant_review_completed) }
+
+      assign_attributes(recommendation: 'Accept')
+      accepted!
+
+      applicant.save!
+    end
+
+    def reject!
+      after_commit { send_email(:applicant_review_completed) }
+
+      assign_attributes(recommendation: 'Reject')
+      rejected!
+
+      applicant.save!
+    end
+
+    private
+
+    def send_email(email)
+      EffectiveMemberships.send_email(email, self, email_form_params) unless email_form_skip?
+    end
+
+  end
+end

data/app/models/concerns/effective_memberships_category.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+# EffectiveMembershipsCategory
+#
+# Mark your category model with effective_memberships_category to get all the includes
+
+module EffectiveMembershipsCategory
+  extend ActiveSupport::Concern
+
+  module Base
+    def effective_memberships_category
+      include ::EffectiveMembershipsCategory
+    end
+  end
+
+  module ClassMethods
+    def effective_memberships_category?; true; end
+
+    def categories
+      []
+    end
+  end
+
+  included do
+    log_changes(except: :memberships) if respond_to?(:log_changes)
+
+    # rich_text_body - Used by the select step
+    has_many_rich_texts
+
+    # rich_text_applicant_all_steps_content
+    # rich_text_applicant_start_content
+    # rich_text_applicant_select_content
+    # rich_text_applicant_select_content
+
+    has_many :membership_categories, class_name: 'Effective::MembershipCategory', as: :category
+
+    effective_resource do
+      title                 :string
+      category              :string
+      position              :integer
+
+      # Applicants
+      can_apply_new             :boolean
+      can_apply_existing        :boolean
+      can_apply_restricted      :boolean
+      can_apply_restricted_ids  :text
+
+      applicant_fee              :integer
+      applicant_wizard_steps     :text
+
+      min_applicant_educations          :integer
+      min_applicant_experiences_months  :integer
+      min_applicant_references          :integer
+      min_applicant_courses             :integer
+      min_applicant_files               :integer
+
+      # Applicant Reviews
+      min_applicant_reviews             :integer
+      applicant_review_wizard_steps     :text
+
+      # Prorated Fees
+      prorated_jan        :integer
+      prorated_feb        :integer
+      prorated_mar        :integer
+      prorated_apr        :integer
+      prorated_may        :integer
+      prorated_jun        :integer
+      prorated_jul        :integer
+      prorated_aug        :integer
+      prorated_sep        :integer
+      prorated_oct        :integer
+      prorated_nov        :integer
+      prorated_dec        :integer
+
+      # Fee Payments
+      fee_payment_wizard_steps   :text
+
+      # Renewals
+      create_renewal_fees   :boolean
+      renewal_fee           :integer
+
+      create_late_fees      :boolean
+      late_fee              :integer
+
+      create_bad_standing  :boolean
+
+      # Pricing
+      qb_item_name          :string
+      tax_exempt            :boolean
+
+      timestamps
+    end
+
+    serialize :can_apply_restricted_ids, Array
+    serialize :applicant_wizard_steps, Array
+    serialize :fee_payment_wizard_steps, Array
+
+    scope :deep, -> { includes(:rich_texts) }
+    scope :sorted, -> { order(:position) }
+
+    scope :can_apply, -> {
+      where(can_apply_new: true)
+      .or(where(can_apply_existing: true))
+      .or(where(can_apply_restricted: true))
+    }
+
+    # For the create_fees rake task
+    scope :create_renewal_fees, -> { where(create_renewal_fees: true) }
+    scope :create_late_fees, -> { where(create_late_fees: true) }
+    scope :create_bad_standing, -> { where(create_bad_standing: true) }
+
+    validates :title, presence: true, uniqueness: true
+    validates :position, presence: true
+
+    after_initialize(if: -> { new_record? }) do
+      self.applicant_wizard_steps = EffectiveMemberships.Applicant.all_wizard_steps
+      self.applicant_review_wizard_steps = EffectiveMemberships.ApplicantReview.all_wizard_steps
+      self.fee_payment_wizard_steps = EffectiveMemberships.FeePayment.all_wizard_steps
+    end
+
+    before_validation do
+      self.position ||= (self.class.pluck(:position).compact.max || -1) + 1
+    end
+
+    with_options(if: -> { can_apply? }) do
+      validates :can_apply_restricted_ids, presence: true, if: -> { can_apply_restricted? }
+
+      validates :applicant_fee, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :prorated_jan, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :prorated_feb, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :prorated_mar, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :prorated_apr, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :prorated_may, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :prorated_jun, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :prorated_jul, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :prorated_aug, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :prorated_sep, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :prorated_oct, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :prorated_nov, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :prorated_dec, presence: true, numericality: { greater_than_or_equal_to: 0 }
+    end
+  end
+
+  # Instance Methods
+
+  def to_s
+    title.presence || 'New Membership Category'
+  end
+
+  def can_apply?
+    can_apply_new? || can_apply_existing? || can_apply_restricted?
+  end
+
+  def prorated_fee(date:)
+    send("prorated_#{date.strftime('%b').downcase}").to_i
+  end
+
+  def discount_fee(date:)
+    0 - prorated_fee(date: date)
+  end
+
+  def can_apply_restricted_ids
+    Array(self[:can_apply_restricted_ids]) - [nil, '']
+  end
+
+  def applicant_wizard_steps
+    (Array(self[:applicant_wizard_steps]) - [nil, '']).map(&:to_sym)
+  end
+
+  def fee_payment_wizard_steps
+    (Array(self[:fee_payment_wizard_steps]) - [nil, '']).map(&:to_sym)
+  end
+
+  def applicant_review_wizard_steps
+    (Array(self[:applicant_review_wizard_steps]) - [nil, '']).map(&:to_sym)
+  end
+
+  def applicant_wizard_steps_collection
+    wizard_steps = EffectiveMemberships.Applicant.const_get(:WIZARD_STEPS)
+    required_steps = EffectiveMemberships.Applicant.required_wizard_steps
+
+    wizard_steps.map do |step, title|
+      [title, step, 'disabled' => required_steps.include?(step)]
+    end
+  end
+
+  def fee_payment_wizard_steps_collection
+    wizard_steps = EffectiveMemberships.FeePayment.const_get(:WIZARD_STEPS)
+    required_steps = EffectiveMemberships.FeePayment.required_wizard_steps
+
+    wizard_steps.map do |step, title|
+      [title, step, 'disabled' => required_steps.include?(step)]
+    end
+  end
+
+end

data/app/models/concerns/effective_memberships_fee_payment.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+# EffectiveMembershipsFeePayment
+#
+# Mark your model with effective_memberships_fee_payment to get all the includes
+
+module EffectiveMembershipsFeePayment
+  extend ActiveSupport::Concern
+
+  module Base
+    def effective_memberships_fee_payment
+      include ::EffectiveMembershipsFeePayment
+    end
+  end
+
+  module ClassMethods
+    def effective_memberships_fee_payment?; true; end
+
+    def all_wizard_steps
+      const_get(:WIZARD_STEPS).keys
+    end
+
+    def required_wizard_steps
+      [:start, :summary, :billing, :checkout, :submitted]
+    end
+  end
+
+  included do
+    acts_as_purchasable_parent
+    acts_as_tokened
+
+    acts_as_statused(
+      :draft,       # Just Started
+      :submitted    # All Done
+    )
+
+    acts_as_wizard(
+      start: 'Start',
+      demographics: 'Demographics',
+      declarations: 'Declarations',
+      summary: 'Review',
+      billing: 'Billing Address',
+      checkout: 'Checkout',
+      submitted: 'Submitted'
+    )
+
+    log_changes(except: :wizard_steps) if respond_to?(:log_changes)
+
+    # Declarations Step
+    attr_accessor :declare_code_of_ethics
+    attr_accessor :declare_truth
+
+    # Application Namespace
+    belongs_to :owner, polymorphic: true
+    accepts_nested_attributes_for :owner
+
+    # Like maybe optionally it makes sense.
+    belongs_to :category, polymorphic: true, optional: true
+
+    has_many :fees, -> { order(:id) }, as: :parent, class_name: 'Effective::Fee', dependent: :nullify
+    accepts_nested_attributes_for :fees, reject_if: :all_blank, allow_destroy: true
+
+    # Effective Namespace
+    has_many :orders, -> { order(:id) }, as: :parent, class_name: 'Effective::Order', dependent: :nullify
+    accepts_nested_attributes_for :orders
+
+    effective_resource do
+      # Acts as Statused
+      status                 :string, permitted: false
+      status_steps           :text, permitted: false
+
+      # Dates
+      period                 :date
+      submitted_at           :datetime
+
+      # Acts as Wizard
+      wizard_steps           :text, permitted: false
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:owner, :category, :orders) }
+    scope :sorted, -> { order(:id) }
+
+    scope :in_progress, -> { where.not(status: [:submitted]) }
+    scope :done, -> { where(status: [:submitted]) }
+
+    before_validation do
+      self.period ||= EffectiveMemberships.Registrar.current_period
+    end
+
+    before_validation(if: -> { current_step == :start && owner && owner.membership }) do
+      self.category ||= owner.membership.categories.first if owner.membership.categories.length == 1
+    end
+
+    validates :period, presence: true
+
+    # All Steps validations
+    validates :owner, presence: true
+
+    # Declarations Step
+    with_options(if: -> { current_step == :declarations }) do
+      validates :declare_code_of_ethics, acceptance: true
+      validates :declare_truth, acceptance: true
+    end
+
+    # Clear required steps memoization
+    after_save { @_required_steps = nil }
+
+    # This required_steps is defined inside the included do .. end block so it overrides the acts_as_wizard one.
+    def required_steps
+      return self.class.test_required_steps if Rails.env.test? && self.class.test_required_steps.present?
+
+      @_required_steps ||= begin
+        wizard_steps = self.class.all_wizard_steps
+        required_steps = self.class.required_wizard_steps
+
+        fee_payment_steps = Array(category&.fee_payment_wizard_steps)
+
+        wizard_steps.select do |step|
+          required_steps.include?(step) || category.blank? || fee_payment_steps.include?(step)
+        end
+      end
+    end
+
+    after_purchase do |_order|
+      raise('expected submit_order to be purchased') unless submit_order&.purchased?
+
+      submit_purchased!
+      after_submit_purchased!
+      EffectiveMemberships.Registrar.fee_payment_purchased!(owner)
+    end
+  end
+
+  def to_s
+    'Fee Payment'
+  end
+
+  # Instance Methods
+  def in_progress?
+    draft?
+  end
+
+  def done?
+    submitted?
+  end
+
+  def can_visit_step?(step)
+    can_revisit_completed_steps(step)
+  end
+
+  def outstanding_fees
+    owner&.outstanding_fee_payment_fees
+  end
+
+  # All Fees and Orders
+  def submit_fees
+    fees
+  end
+
+  def submit_order
+    orders.first
+  end
+
+  # We take over the owner's outstanding fees.
+  def find_or_build_submit_fees
+    Array(outstanding_fees).each { |fee| fees << fee }
+    submit_fees
+  end
+
+  def find_or_build_submit_order
+    order = submit_order || orders.build(user: owner)
+
+    submit_fees.each do |fee|
+      order.add(fee) unless order.purchasables.include?(fee)
+    end
+
+    order.billing_address = owner.billing_address if owner.billing_address.present?
+
+    order
+  end
+
+  # Should be indempotent.
+  def build_submit_fees_and_order
+    return false if was_submitted?
+
+    fees = find_or_build_submit_fees()
+    raise('already has purchased submit fees') if fees.any? { |fee| fee.purchased? }
+
+    order = find_or_build_submit_order()
+    raise('already has purchased submit order') if order.purchased?
+
+    true
+  end
+
+  # Owner clicks on the Billing Submit. Next step is Checkout
+  def billing!
+    ready!
+  end
+
+  def ready!
+    build_submit_fees_and_order
+    save!
+  end
+
+
+  # Called automatically via after_purchase hook above
+  def submit_purchased!
+    return false if was_submitted?
+
+    wizard_steps[:checkout] = Time.zone.now
+    submit!
+  end
+
+  # A hook to extend
+  def after_submit_purchased!
+  end
+
+  # Draft -> Submitted
+  def submit!
+    raise('already submitted') if was_submitted?
+    raise('expected a purchased order') unless submit_order&.purchased?
+
+    wizard_steps[:checkout] ||= Time.zone.now
+    wizard_steps[:submitted] = Time.zone.now
+    submitted!
+  end
+
+end