effective_memberships 0.1.2

data/app/models/effective/applicant_experience.rb

@@ -0,0 +1,79 @@
+module Effective
+  class ApplicantExperience < ActiveRecord::Base
+    belongs_to :applicant
+
+    log_changes(to: :applicant) if respond_to?(:log_changes)
+
+    LEVELS = ['Full Time', 'Part Time', 'Volunteer']
+    ONE_HUNDRED_PERCENT = 100_000
+
+    effective_resource do
+      position          :string
+      employer          :string
+
+      start_on          :date
+      end_on            :date
+
+      percent_worked    :integer  # 3 digits of precision. 50_000 == 50%
+      still_work_here   :boolean
+
+      level             :string
+      tasks_performed   :text
+
+      months            :integer
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:applicant) }
+
+    before_validation(if: -> { start_on.present? && end_on.present? }) do
+      self.months ||= ((end_on - start_on) / 1.month).to_i
+    end
+
+    validates :position, presence: true
+    validates :employer, presence: true
+    validates :start_on, presence: true
+    validates :end_on, presence: true
+    validates :level, presence: true, inclusion: { in: LEVELS }
+    validates :months, presence: true
+
+    validates :percent_worked, presence: true,
+      inclusion: { in: 0..ONE_HUNDRED_PERCENT, message: 'must be between 0 and 100%' }
+
+    validate(if: -> { start_on.present? && end_on.present? }) do
+      errors.add(:end_on, 'must be after start date') unless start_on < end_on
+    end
+
+    def to_s
+      position.presence || 'work experience'
+    end
+
+    def assign_months!
+      return 0 unless end_on.present? && start_on.present?
+
+      self.percent_worked ||= (part_time? ? 0 : ONE_HUNDRED_PERCENT)
+
+      months = ((end_on.end_of_day.to_time - start_on.to_time) / 1.month.second).ceil
+      months *= (percent_worked / ONE_HUNDRED_PERCENT.to_f)
+
+      self.months = months
+    end
+
+    def percent_worked_to_s
+      (percent_worked.to_i / 1000.to_f).to_i.to_s + '%'
+    end
+
+    def full_time?
+      level == 'Full Time'
+    end
+
+    def part_time?
+      level == 'Part Time'
+    end
+
+    def volunteer?
+      level == 'Volunteer'
+    end
+  end
+end

data/app/models/effective/applicant_reference.rb

@@ -0,0 +1,81 @@
+module Effective
+  class ApplicantReference < ActiveRecord::Base
+    acts_as_tokened
+    acts_as_addressable :reference
+    acts_as_statused :submitted, :completed
+    log_changes(to: :applicant) if respond_to?(:log_changes)
+
+    belongs_to :applicant
+
+    KNOWNS = ['6 months - 1 year', '1 year - 2 years', '2 - 5 years', '5 - 10 years', 'More than 10 years']
+    RELATIONSHIPS = ['Supervisor', 'Employer', 'Colleague', 'Other']
+
+    effective_resource do
+      # These two fields are submitted on the Applicant wizard step
+      name    :string
+      email   :string
+      phone   :string
+
+      # As per acts_as_statused. For tracking the state machine.
+      status            :string
+      status_steps      :text
+
+      # Reference Declaration
+      known                   :string
+      relationship            :string
+
+      reservations            :boolean
+      reservations_reason     :text
+
+      work_history            :text
+
+      accept_declaration      :boolean
+
+      # Tracking the submission
+      token                     :string
+      last_notified_at          :datetime
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:applicant) }
+
+    # All step validations
+    validates :applicant, presence: true
+
+    validates :name, presence: true
+    validates :email, presence: true, email: true
+    validates :phone, presence: true
+
+    validates :relationship, presence: true
+    validates :known, presence: true
+
+    # When being submit by the reference
+    with_options(if: -> { completed? }) do
+      validates :reference_address, presence: true
+      validates :reservations_reason, presence: true, if: -> { completed? && reservations? }
+      validates :work_history, presence: true
+      validates :accept_declaration, acceptance: true
+    end
+
+    after_commit(on: :create, if: -> { applicant.submitted? }) { notify! }
+
+    def to_s
+      'reference'
+    end
+
+    def notify!
+      raise('expected reference email') unless email.present?
+
+      EffectiveMemberships.send_email(:applicant_reference_notification, self)
+      update!(last_notified_at: Time.zone.now)
+    end
+
+    def complete!
+      completed!
+      applicant.save!
+    end
+
+  end
+
+end

data/app/models/effective/applicant_review.rb

@@ -0,0 +1,7 @@
+module Effective
+  class ApplicantReview < ActiveRecord::Base
+    self.table_name = EffectiveMemberships.applicant_reviews_table_name.to_s
+
+    effective_memberships_applicant_review
+  end
+end

data/app/models/effective/category.rb

@@ -0,0 +1,7 @@
+module Effective
+  class Category < ActiveRecord::Base
+    self.table_name = EffectiveMemberships.categories_table_name.to_s
+
+    effective_memberships_category
+  end
+end

data/app/models/effective/fee.rb

@@ -0,0 +1,142 @@
+module Effective
+  class Fee < ActiveRecord::Base
+    acts_as_purchasable
+
+    log_changes(to: :owner) if respond_to?(:log_changes)
+
+    # Every fee is charged to a owner
+    belongs_to :owner, polymorphic: true
+
+    # This fee may belong to an application, fee payment, or other parent model
+    belongs_to :parent, polymorphic: true, optional: true
+
+    # The membership category for this fee, if there's only 1 membership.categories
+    belongs_to :category, polymorphic: true, optional: true
+
+    effective_resource do
+      fee_type      :string
+
+      title         :string
+
+      period        :date
+
+      late_on           :date
+      bad_standing_on   :date
+
+      price             :integer
+      qb_item_name      :string
+      tax_exempt        :boolean
+
+      timestamps
+    end
+
+    scope :sorted, -> { order(:id) }
+    scope :deep, -> { includes(:owner, :parent, :category) }
+
+    before_validation(if: -> { owner.present? }) do
+      additional = owner.additional_fee_attributes(self)
+      raise('expected a Hash of attributes') unless additional.kind_of?(Hash)
+      assign_attributes(additional)
+    end
+
+    before_validation(if: -> { owner && owner.membership }) do
+      self.category ||= owner.membership.categories.first if owner.membership.categories.length == 1
+    end
+
+    before_validation do
+      self.period ||= default_period()
+      self.late_on ||= default_late_on()
+      self.bad_standing_on ||= default_bad_standing_on()
+
+      self.qb_item_name ||= default_qb_item_name()
+      self.tax_exempt = default_tax_exempt() if tax_exempt.nil?
+
+      self.title ||= default_title()
+    end
+
+    validates :fee_type, presence: true
+    validates :price, presence: true
+
+    validates :title, presence: true
+    validates :period, presence: true
+    validates :qb_item_name, presence: true
+
+    validate(if: -> { fee_type.present? }) do
+      self.errors.add(:fee_type, 'is not included') unless EffectiveMemberships.fee_types.include?(fee_type)
+    end
+
+    validates :late_on, presence: true,
+      if: -> { fee_type == 'Renewal' && category&.create_late_fees? }
+
+    validates :bad_standing_on, presence: true,
+      if: -> { fee_type == 'Renewal' && category&.create_bad_standing? }
+
+    def to_s
+      title.presence || default_title()
+    end
+
+    def late?
+      return false if late_on.blank?
+      return false if purchased?
+
+      late_on <= Time.zone.now.to_date
+    end
+
+    def bad_standing?
+      return false if bad_standing_on.blank?
+      return false if purchased?
+
+      bad_standing_on <= Time.zone.now.to_date
+    end
+
+    # Used by applicant.applicant_submit_fees
+    def applicant_submit_fee?
+      fee_type == 'Applicant'
+    end
+
+    def fee_payment_fee?
+      fee_type != 'Applicant'
+    end
+
+    # Will advance a membership.fees_paid_through_year value when purchased
+    def membership_period_fee?
+      fee_type == 'Prorated' || fee_type == 'Renewal'
+    end
+
+    def custom_fee?
+      EffectiveMemberships.custom_fee_types.include?(fee_type)
+    end
+
+    private
+
+    def default_period
+      EffectiveMemberships.Registrar.current_period
+    end
+
+    def default_late_on
+      nil
+    end
+
+    def default_bad_standing_on
+      nil
+    end
+
+    def default_title
+      [
+        period&.strftime('%Y').presence,
+        category.to_s.presence,
+        fee_type.presence,
+        'Fee'
+      ].join(' ')
+    end
+
+    def default_qb_item_name
+      "#{fee_type} Fee"
+    end
+
+    def default_tax_exempt
+      false
+    end
+
+  end
+end

data/app/models/effective/fee_payment.rb

@@ -0,0 +1,7 @@
+module Effective
+  class FeePayment < ActiveRecord::Base
+    self.table_name = EffectiveMemberships.fee_payments_table_name.to_s
+
+    effective_memberships_fee_payment
+  end
+end

data/app/models/effective/membership.rb

@@ -0,0 +1,119 @@
+module Effective
+  class Membership < ActiveRecord::Base
+    belongs_to :owner, polymorphic: true
+
+    has_many :membership_categories, -> { order(:id) }, inverse_of: :membership, dependent: :delete_all
+    accepts_nested_attributes_for :membership_categories
+
+    log_changes(to: :owner) if respond_to?(:log_changes)
+
+    effective_resource do
+      # Membership Info
+      number                    :string   # A unique value
+      number_as_integer         :integer  # A unique integer
+
+      joined_on                 :date     # When they first receive a membership category
+      registration_on           :date     # When the membership category last changed. Applied or reclassified.
+
+      # Membership Status
+      fees_paid_period          :date     # The most recent period they have paid in. Start date of period.
+      fees_paid_through_period  :date     # The most recent period they have paid in. End date of period. Kind of an expires.
+
+      bad_standing              :boolean   # Calculated value. Is this owner in bad standing? (fees due)
+      bad_standing_admin        :boolean   # Admin set this
+      bad_standing_reason       :text      # Reason for bad standing
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(owner: [:fees, :membership]) }
+    scope :sorted, -> { order(:id) }
+
+    scope :with_paid_fees_through, -> (period = nil) {
+      where(arel_table[:fees_paid_period].gteq(period || EffectiveMemberships.Registrar.current_period))
+    }
+
+    scope :with_unpaid_fees_through, -> (period = nil) {
+      where(arel_table[:fees_paid_period].lt(period || EffectiveMemberships.Registrar.current_period))
+      .or(where(fees_paid_period: nil))
+    }
+
+    scope :create_renewal_fees, -> (period = nil) {
+      deep.with_unpaid_fees_through(period)
+        .where.not(fees_paid_period: nil) # Must have purchased a Prorated or Renewal Fee before
+        #.where(category_id: EffectiveMemberships.Category.create_renewal_fees)
+    }
+
+    scope :create_late_fees, -> (period = nil) {
+      deep.with_unpaid_fees_through(period)
+        .where.not(fees_paid_period: nil) # Must have purchased a Prorated or Renewal Fee before
+        #.where(category_id: EffectiveMemberships.Category.create_late_fees)
+    }
+
+    scope :create_bad_standing, -> (period = nil) {
+      deep.with_unpaid_fees_through(period)
+        .where.not(fees_paid_period: nil) # Must have purchased a Prorated or Renewal Fee before
+        #.where(category_id: EffectiveMemberships.Category.create_bad_standing)
+    }
+
+    before_validation do
+      self.registration_on ||= joined_on
+      self.number_as_integer ||= (Integer(number) rescue nil)
+    end
+
+    validates :number, presence: true, uniqueness: true
+    validates :joined_on, presence: true
+    validates :registration_on, presence: true
+
+    validate(if: -> { owner.present? }) do
+      self.errors.add(:owner_id, 'must be a memberships owner') unless owner.class.effective_memberships_owner?
+    end
+
+    def self.max_number
+      maximum('number_as_integer') || 0
+    end
+
+    def to_s
+      'membership'
+    end
+
+    # We can't use the polymorphic has_many. So this is a helper.
+    def categories
+      membership_categories.reject(&:marked_for_destruction?).map(&:category)
+    end
+
+    def category_ids
+      membership_categories.reject(&:marked_for_destruction?).map(&:category_id)
+    end
+
+    # We might want to use singular memberships.
+    def category
+      raise('expected singular usage but there are more than one membership') if categories.length > 1
+      categories.first
+    end
+
+    def category_id
+      raise('expected singular usage but there are more than one membership') if categories.length > 1
+      categories.first.id
+    end
+
+    def membership_category(category:)
+      raise('expected a category') unless category.class.respond_to?(:effective_memberships_category?)
+      membership_categories.find { |mc| mc.category_id == category.id && mc.category_type == category.class.name }
+    end
+
+    # find or build
+    def build_membership_category(category:)
+      membership_category(category: category) || membership_categories.build(category: category)
+    end
+
+    def good_standing?
+      !bad_standing?
+    end
+
+    def fees_paid?
+      fees_paid_period == EffectiveMemberships.Registrar.current_period
+    end
+
+  end
+end

data/app/models/effective/membership_category.rb

@@ -0,0 +1,11 @@
+module Effective
+  class MembershipCategory < ActiveRecord::Base
+    belongs_to :category, polymorphic: true
+    belongs_to :membership, polymorphic: true
+
+    def to_s
+      'membership category'
+    end
+
+  end
+end

data/app/models/effective/membership_history.rb

@@ -0,0 +1,40 @@
+module Effective
+  class MembershipHistory < ActiveRecord::Base
+    belongs_to :owner, polymorphic: true
+
+    effective_resource do
+      start_on       :date
+      end_on         :date
+
+      number         :string
+
+      bad_standing   :boolean
+      removed        :boolean
+
+      categories      :text
+      category_ids    :text
+
+      notes          :text
+
+      timestamps
+    end
+
+    serialize :categories, Array
+    serialize :category_ids, Array
+
+    scope :deep, -> { includes(:owner) }
+    scope :sorted, -> { order(:start_on) }
+
+    validates :owner, presence: true
+
+    validates :categories, presence: true, unless: -> { removed? }
+    validates :category_ids, presence: true, unless: -> { removed? }
+
+    validates :start_on, presence: true
+
+    def to_s
+      'membership history'
+    end
+
+  end
+end

data/app/models/effective/registrar.rb

@@ -0,0 +1,19 @@
+module Effective
+  class Registrar
+
+    include EffectiveMembershipsRegistrar
+
+    def renewal_fee_date(date:)
+      Date.new(date.year, 12, 1) # Fees roll over every December 1st
+    end
+
+    def late_fee_date(period:)
+      Date.new(period.year, 2, 1) # Fees are late after February 1st
+    end
+
+    def bad_standing_date(period:)
+      Date.new(period.year, 3, 1) # Membership in bad standing after March 1st
+    end
+
+  end
+end

data/app/models/effective/registrar_action.rb

@@ -0,0 +1,97 @@
+# Form Object for the Admin Change Status screens
+
+module Effective
+  class RegistrarAction
+    include ActiveModel::Model
+
+    # All Actions
+    attr_accessor :current_user
+    attr_accessor :current_action
+    attr_accessor :owner, :owner_id, :owner_type
+
+    # Bad Standing
+    attr_accessor :bad_standing_reason
+
+    # Reclassify & Register
+    attr_accessor :category_id
+    attr_accessor :membership_number
+    attr_accessor :skip_fees
+
+    # All Action Validations
+    validates :current_action, presence: true
+    validates :current_user, presence: true
+    validates :owner, presence: true
+
+    # Bad Standing
+    validates :bad_standing_reason, presence: true, if: -> { current_action == :bad_standing }
+
+    # Reclassification & Register
+    validates :category_id, presence: true,
+      if: -> { current_action == :reclassify || current_action == :register }
+
+    def to_s
+      'action'
+    end
+
+    def good_standing!
+      update!(current_action: :good_standing)
+      EffectiveMemberships.Registrar.good_standing!(owner)
+    end
+
+    def bad_standing!
+      update!(current_action: :bad_standing)
+      EffectiveMemberships.Registrar.bad_standing!(owner, reason: bad_standing_reason)
+    end
+
+    def reclassify!
+      update!(current_action: :reclassify)
+      EffectiveMemberships.Registrar.reclassify!(owner, to: category, skip_fees: skip_fees?)
+    end
+
+    def fees_paid!
+      update!(current_action: :fees_paid)
+      EffectiveMemberships.Registrar.fees_paid!(owner)
+    end
+
+    def remove!
+      update!(current_action: :remove)
+      EffectiveMemberships.Registrar.remove!(owner)
+    end
+
+    def register!
+      update!(current_action: :register)
+      EffectiveMemberships.Registrar.register!(owner, to: category, number: membership_number.presence, skip_fees: skip_fees?)
+    end
+
+    def update!(atts)
+      assign_attributes(atts); save!
+    end
+
+    def save!
+      valid? ? true : raise('invalid')
+    end
+
+    def owner
+      @owner ||= (@owner_type.constantize.find(@owner_id) if @owner_type && @owner_id)
+    end
+
+    def owner_type
+      @owner_type || (@owner.class.name if @owner)
+    end
+
+    def owner_id
+      @owner_id || (@owner.id if @owner)
+    end
+
+    private
+
+    def category
+      EffectiveMemberships.Category.find(@category_id) if @category_id
+    end
+
+    def skip_fees?
+      EffectiveResources.truthy?(@skip_fees)
+    end
+
+  end
+end

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

@@ -0,0 +1,8 @@
+= tabs do
+  = tab 'Course Area' do
+    = render 'admin/applicant_course_areas/form_applicant_course_area', applicant_course_area: applicant_course_area
+
+  - if applicant_course_area.persisted?
+    - if applicant_course_area.respond_to?(:log_changes_datatable)
+      = tab 'Logs' do
+        = render_inline_datatable(applicant_course_area.log_changes_datatable)

data/app/views/admin/applicant_course_areas/_form_applicant_course_area.html.haml

@@ -0,0 +1,8 @@
+= effective_form_with(model: [:admin, applicant_course_area], engine: true) do |f|
+  = f.text_field :title
+  = effective_submit(f)
+
+- if applicant_course_area.persisted?
+  %h2 Course Names
+  - datatable = Admin::EffectiveApplicantCourseNamesDatatable.new(applicant_course_area_id: applicant_course_area.id)
+  = render_datatable(datatable, inline: true)

data/app/views/admin/applicant_course_areas/index.html.haml

@@ -0,0 +1,8 @@
+.row
+  .col-8
+    %h1.effective-admin-heading= @page_title
+  .col-4.text-right
+    = render_resource_buttons(Effective::ApplicantCourseArea, :index => false)
+
+%p Click Reorder to drag & drop reorder the position of these items.
+= render_datatable(@datatable)

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

@@ -0,0 +1,9 @@
+= effective_form_with(model: [:admin, applicant_course_name], engine: true) do |f|
+  - if inline_datatable?
+    = f.hidden_field :applicant_course_area_id
+  - else
+    = f.select :applicant_course_area_id, Effective::ApplicantCourseArea.all
+
+  = f.text_field :title
+
+  = f.submit

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

@@ -0,0 +1,38 @@
+= tabs do
+  - # Done applicants have the Applicant tab first. In progress ones the Status tab
+  - if applicant.done?
+    = tab 'Applicant' do
+      .mb-4= render 'effective/applicants/summary', applicant: applicant, namespace: :admin
+      = render 'effective/applicants/applicant', applicant: applicant, namespace: :admin
+
+    = tab 'Status' do
+      = render 'admin/applicants/status', applicant: applicant, namespace: :admin
+
+  - if applicant.in_progress?
+    = tab 'Status' do
+      = render 'admin/applicants/status', applicant: applicant, namespace: :admin
+
+    = tab 'Applicant' do
+      .mb-4= render 'effective/applicants/summary', applicant: applicant, namespace: :admin
+      = render 'effective/applicants/applicant', applicant: applicant, namespace: :admin
+
+  - # Just normal tabs now
+  - if applicant.was_submitted? && !applicant.was_approved?
+    = tab 'Process' do
+      = render 'admin/applicants/form_process', applicant: applicant
+
+  - if applicant.fees.present?
+    = tab 'Fees' do
+      .mb-4= render_inline_datatable(Admin::EffectiveFeesDatatable.new(applicant_id: applicant.to_param))
+
+  - if applicant.orders.present?
+    = tab 'Orders' do
+      .mb-4= render_datatable(Admin::EffectiveOrdersDatatable.new(parent_id: applicant.id, parent_type: EffectiveMemberships.Applicant.name, owner_id: applicant.owner_id, user_type: applicant.owner_type))
+
+  - if applicant.owner.applicants.any? { |other| other.was_submitted? && other.id != applicant.id }
+    = tab 'Other Applications' do
+      = render_datatable(Admin::EffectiveApplicantsDatatable.new(owner_id: applicant.owner_id, except_id: applicant.id))
+
+  - if applicant.persisted? && applicant.respond_to?(:log_changes_datatable)
+    = tab 'Logs' do
+      = render_inline_datatable(applicant.log_changes_datatable)