effective_memberships 0.1.2

data/app/models/concerns/effective_memberships_owner.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+# EffectiveMembershipsOwner
+#
+# Mark your owner model with effective_memberships_owner to get all the includes
+
+module EffectiveMembershipsOwner
+  extend ActiveSupport::Concern
+
+  mattr_accessor :descendants
+
+  module Base
+    def effective_memberships_owner
+      include ::EffectiveMembershipsOwner
+      (EffectiveMembershipsOwner.descendants ||= []) << self
+    end
+  end
+
+  module ClassMethods
+    def effective_memberships_owner?; true; end
+  end
+
+  included do
+    # App scoped
+    has_many :applicants, as: :owner
+    has_many :fee_payments, as: :owner
+
+    # Effective scoped
+    has_many :fees, -> { order(:id) }, inverse_of: :owner, as: :owner, class_name: 'Effective::Fee', dependent: :nullify
+    accepts_nested_attributes_for :fees, reject_if: :all_blank, allow_destroy: true
+
+    has_many :orders, -> { order(:id) }, inverse_of: :user, as: :user, class_name: 'Effective::Order', dependent: :nullify
+    accepts_nested_attributes_for :orders, reject_if: :all_blank, allow_destroy: true
+
+    has_one :membership, inverse_of: :owner, as: :owner, class_name: 'Effective::Membership'
+    accepts_nested_attributes_for :membership
+
+    has_many :membership_histories, -> { Effective::MembershipHistory.sorted }, inverse_of: :owner, as: :owner, class_name: 'Effective::MembershipHistory'
+    accepts_nested_attributes_for :membership_histories
+
+    effective_resource do
+      timestamps
+    end
+
+    scope :members, -> { joins(:membership) }
+  end
+
+  def effective_memberships_owner
+    self
+  end
+
+  def owner_label
+    self.class.name.split('::').last
+  end
+
+  def membership_fees_paid?
+    outstanding_fee_payment_fees.blank? && membership && membership.fees_paid?
+  end
+
+  def outstanding_fee_payment_fees
+    fees.select { |fee| fee.fee_payment_fee? && !fee.purchased? }
+  end
+
+  def outstanding_fee_payment_orders
+    orders.select { |order| order.parent_type.to_s.include?('FeePayment') && !order.purchased? }
+  end
+
+  def bad_standing_fees
+    fees.select { |fee| fee.bad_standing? }
+  end
+
+  def max_fees_paid_period
+    fees.select { |fee| fee.membership_period_fee? && fee.purchased? }.map(&:period).max
+  end
+
+  def max_fees_paid_through_period
+    return nil if max_fees_paid_period.blank?
+    EffectiveMemberships.Registrar.period_end_on(date: max_fees_paid_period)
+  end
+
+  def membership_removed?
+    membership.blank? && membership_histories.any? { |history| history.removed? }
+  end
+
+  def membership_removed_on
+    return nil unless membership_removed?
+    membership_histories.find { |history| history.removed? }.start_on
+  end
+
+  # Instance Methods
+  def additional_fee_attributes(fee)
+    raise('expected an Effective::Fee') unless fee.kind_of?(Effective::Fee)
+    {}
+  end
+
+  def build_prorated_fee(date: nil)
+    raise('must have an existing membership') unless membership.present?
+
+    date ||= Time.zone.now
+    price = membership.category.prorated_fee(date: date)
+    period = EffectiveMemberships.Registrar.period(date: date)
+    category = membership.category
+
+    fee = fees.find { |fee| fee.fee_type == 'Prorated' && fee.period == period && fee.category == category } || fees.build()
+    return fee if fee.purchased?
+
+    fee.assign_attributes(
+      fee_type: 'Prorated',
+      category: category,
+      price: price,
+      period: period
+    )
+
+    fee
+  end
+
+  def build_discount_fee(from:, date: nil)
+    raise('must have an existing membership') unless membership.present?
+    raise('existing membership category may not be same as from') if membership.category == from
+
+    date ||= Time.zone.now
+    price = from.discount_fee(date: date)
+    period = EffectiveMemberships.Registrar.period(date: date)
+    category = membership.category
+
+    fee = fees.find { |fee| fee.fee_type == 'Discount' && fee.period == period && fee.category == category } || fees.build()
+    return fee if fee.purchased?
+
+    fee.assign_attributes(
+      fee_type: 'Discount',
+      category: category,
+      price: price,
+      period: period
+    )
+
+    fee
+  end
+
+  def build_title_fee(period:, title:, fee_type: nil, category: nil, price: nil, qb_item_name: nil, tax_exempt: nil)
+    fee_type ||= 'Renewal'
+
+    fee = fees.find do |fee|
+      fee.fee_type == fee_type && fee.period == period && fee.title == title &&
+      (category.blank? || fee.category_id == category.id && fee.category_type == category.class.name)
+    end
+
+    return fee if fee&.purchased?
+
+    # Build the title fee
+    fee ||= fees.build()
+    price ||= (category.renewal_fee.to_i if category.present? && fee_type == 'Renewal')
+
+    fee.assign_attributes(
+      fee_type: fee_type,
+      title: title,
+      category: category,
+      price: price,
+      period: period,
+      qb_item_name: qb_item_name,
+      tax_exempt: tax_exempt,
+      late_on: nil,
+      bad_standing_on: nil
+    )
+  end
+
+  def build_renewal_fee(category:, period:, late_on:, bad_standing_on:)
+    raise('must have an existing membership') unless membership.present?
+
+    fee = fees.find { |fee| fee.fee_type == 'Renewal' && fee.period == period && fee.category_id == category.id && fee.category_type == category.class.name }
+    return fee if fee&.purchased?
+
+    # Build the renewal fee
+    fee ||= fees.build()
+
+    fee.assign_attributes(
+      fee_type: 'Renewal',
+      category: category,
+      price: category.renewal_fee.to_i,
+      period: period,
+      late_on: late_on,
+      bad_standing_on: bad_standing_on
+    )
+
+    fee
+  end
+
+  def build_late_fee(category:, period:)
+    raise('must have an existing membership') unless membership.present?
+
+    # Return existing but do not build yet
+    fee = fees.find { |fee| fee.fee_type == 'Late' && fee.period == period && fee.category_id == category.id && fee.category_type == category.class.name }
+    return fee if fee&.purchased?
+
+    # Only continue if there is a late renewal fee for the same period
+    renewal_fee = fees.find { |fee| fee.fee_type == 'Renewal' && fee.period == period && fee.category_id == category.id && fee.category_type == category.class.name }
+    return unless fee.present? || renewal_fee&.late?
+
+    # Build the late fee
+    fee ||= fees.build()
+
+    fee.assign_attributes(
+      fee_type: 'Late',
+      category: category,
+      price: category.late_fee.to_i,
+      period: period,
+    )
+
+    fee
+  end
+
+  def update_membership_status!
+    raise('expected membership to be present') unless membership.present?
+
+    # Assign fees paid through period
+    membership.fees_paid_period = max_fees_paid_period()
+    membership.fees_paid_through_period = max_fees_paid_through_period()
+
+    # Assign in bad standing
+    if membership.bad_standing_admin?
+      # Nothing to do
+    elsif bad_standing_fees.present?
+      membership.bad_standing = true
+      membership.bad_standing_reason = 'Unpaid Fees'
+    else
+      membership.bad_standing = false
+      membership.bad_standing_reason = nil
+    end
+
+    if membership.bad_standing_changed? || membership_histories.blank?
+      build_membership_history()
+    end
+
+    save!
+  end
+
+  def build_membership_history(start_on: nil)
+    raise('expected membership to be present') unless membership.present?
+
+    # The date of change
+    start_on ||= Time.zone.now
+    removed = membership.marked_for_destruction?
+
+    # End the other membership histories
+    membership_histories.each { |history| history.end_on ||= start_on }
+
+    # Snapshot of the current membership at this time
+    membership_histories.build(
+      start_on: start_on,
+      end_on: nil,
+      removed: removed,
+      bad_standing: membership.bad_standing?,
+      categories: (membership.categories.map(&:to_s) unless removed),
+      category_ids: (membership.categories.map(&:id) unless removed),
+      number: (membership.number unless removed)
+    )
+  end
+
+  def membership_history_on(date)
+    raise('expected a date') unless date.respond_to?(:strftime)
+    membership_histories.find { |history| (history.start_on..history.end_on).cover?(date) } # Ruby 2.6 supports endless ranges
+  end
+
+end

data/app/models/concerns/effective_memberships_registrar.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+# EffectiveMembershipsRegistrar
+#
+# This is different cause its not an ActiveRecord one
+#
+# Mark your registrar with include EffectiveMembershipsRegistrar
+#
+# Mark your category model with effective_memberships_category to get all the includes
+
+module EffectiveMembershipsRegistrar
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def effective_memberships_registrar?; true; end
+  end
+
+  included do
+  end
+
+  def renewal_fee_date(date:)
+    Date.new(date.year, 12, 1) # Fees roll over every December 1st
+    raise('to be implemented by app registrar')
+  end
+
+  def late_fee_date(period:)
+    Date.new(period.year, 2, 1) # Fees are late after February 1st
+    raise('to be implemented by app registrar')
+  end
+
+  def bad_standing_date(period:)
+    Date.new(period.year, 3, 1) # Membership in bad standing after March 1st
+    raise('to be implemented by app registrar')
+  end
+
+  def assign!(owner, categories:, date: nil, number: nil)
+    categories = Array(categories)
+
+    raise('expecting a memberships owner') unless owner.class.respond_to?(:effective_memberships_owner?)
+    raise('expecting a membership category') unless categories.all? { |cat| cat.class.respond_to?(:effective_memberships_category?) }
+
+    # Default Date and next number
+    date ||= Time.zone.now
+    number = next_membership_number(owner, to: categories.first) if number.blank?
+    period = period(date: date)
+    period_end_on = period_end_on(date: date)
+
+    # Find or build a membership
+    membership = owner.membership || owner.build_membership
+
+    # Assign Dates
+    membership.joined_on ||= date  # Only if not already present
+
+    # Assign Number
+    membership.number ||= number
+    membership.number_as_integer ||= (Integer(number) rescue nil)
+
+    # Delete any removed categories
+    membership.membership_categories.each do |membership_category|
+      next if categories.include?(membership_category.category)
+      membership_category.mark_for_destruction
+    end
+
+    # Build any additional categories
+    categories.each do |category|
+      membership.build_membership_category(category: category)
+    end
+
+    changed = membership.membership_categories.any? { |mc| mc.new_record? || mc.marked_for_destruction? }
+
+    if changed
+      membership.registration_on = date # Always new registration_on
+      save!(owner, date: date)
+    end
+
+    owner.update_membership_status!
+  end
+
+  def register!(owner, to:, date: nil, number: nil, skip_fees: false)
+    raise('expecting a memberships owner') unless owner.class.respond_to?(:effective_memberships_owner?)
+    raise('expecting a memberships category') unless to.class.respond_to?(:effective_memberships_category?)
+    raise('owner has existing membership. use reclassify! instead.') if owner.membership.present?
+
+    # Default Date and next number
+    date ||= Time.zone.now
+    number = next_membership_number(owner, to: to) if number.blank?
+    period = period(date: date)
+    period_end_on = period_end_on(date: date)
+
+    # Build a membership
+    membership = owner.build_membership
+
+    # Assign Dates
+    membership.joined_on ||= date  # Only if not already present
+    membership.registration_on = date  # Always new registration_on
+
+    # Assign Number
+    membership.number = number
+    membership.number_as_integer = (Integer(number) rescue nil)
+
+    # Assign Category
+    membership.build_membership_category(category: to)
+
+    # Assign fees paid through period
+    if skip_fees
+      membership.fees_paid_period = period
+      membership.fees_paid_through_period = period_end_on
+    end
+
+    # Or, Build Fees
+    unless skip_fees
+      fee = owner.build_prorated_fee(date: date)
+      raise('already has purchased prorated fee') if fee.purchased?
+    end
+
+    # Save owner
+    save!(owner, date: date)
+  end
+
+  def reclassify!(owner, to:, date: nil, skip_fees: false)
+    raise('expecting a memberships owner') unless owner.class.respond_to?(:effective_memberships_owner?)
+    raise('owner must have an existing membership. use register! instead') if owner.membership.blank?
+
+    # Todo. I dunno this was owner.membership.category
+    from = owner.membership.category
+
+    raise('expecting a to memberships category') unless to.class.respond_to?(:effective_memberships_category?)
+    raise('expecting a from memberships category') unless from.class.respond_to?(:effective_memberships_category?)
+    raise('expected to and from to be different') if from == to
+
+    date ||= Time.zone.now
+
+    membership = owner.membership
+
+    # Assign Category
+    membership.registration_on = date
+
+    membership.build_membership_category(category: to)
+    membership.membership_category(category: from).mark_for_destruction
+
+    unless skip_fees
+      fee = owner.build_prorated_fee(date: date)
+      raise('already has purchased prorated fee') if fee.purchased?
+
+      fee = owner.build_discount_fee(date: date, from: from)
+      raise('already has purchased discount fee') if fee.purchased?
+    end
+
+    save!(owner, date: date)
+  end
+
+  def remove!(owner, date: nil)
+    raise('expecting a memberships owner') unless owner.class.respond_to?(:effective_memberships_owner?)
+    raise('expected a member') unless owner.membership.present?
+
+    # Date
+    date ||= Time.zone.now
+
+    # Remove Membership
+    owner.membership.mark_for_destruction
+
+    # Delete unpurchased fees and orders
+    owner.outstanding_fee_payment_fees.each { |fee| fee.mark_for_destruction }
+    owner.outstanding_fee_payment_orders.each { |order| order.mark_for_destruction }
+
+    save!(owner, date: date)
+  end
+
+  def bad_standing!(owner, reason:, date: nil)
+    raise('expecting a memberships owner') unless owner.class.respond_to?(:effective_memberships_owner?)
+    raise('expected a member') unless owner.membership.present?
+    raise('expected owner to be in good standing') if owner.membership.bad_standing?
+
+    # Date
+    date ||= Time.zone.now
+    membership = owner.membership
+
+    membership.bad_standing = true
+    membership.bad_standing_admin = true
+    membership.bad_standing_reason = reason
+
+    save!(owner, date: date)
+  end
+
+  def good_standing!(owner, date: nil)
+    raise('expecting a memberships owner') unless owner.class.respond_to?(:effective_memberships_owner?)
+    raise('expected a member') unless owner.membership.present?
+    raise('expected owner to be in bad standing') unless owner.membership.bad_standing?
+
+    # Date
+    date ||= Time.zone.now
+    membership = owner.membership
+
+    membership.bad_standing = false
+    membership.bad_standing_admin = false
+    membership.bad_standing_reason = nil
+
+    save!(owner, date: date)
+  end
+
+  def fees_paid!(owner, date: nil)
+    raise('expecting a memberships owner') unless owner.class.respond_to?(:effective_memberships_owner?)
+    raise('expected a member') unless owner.membership.present?
+
+    # Date
+    date ||= Time.zone.now
+
+    period = period(date: date)
+    period_end_on = period_end_on(date: date)
+
+    if owner.outstanding_fee_payment_fees.present?
+      fp = EffectiveMemberships.FeePayment.new(owner: owner)
+      fp.ready!
+      fp.submit_order.purchase!(skip_buyer_validations: true, email: false)
+    end
+
+    owner.membership.update!(fees_paid_period: period, fees_paid_through_period: period_end_on)
+  end
+
+  def next_membership_number(owner, to:)
+    raise('expecting a memberships owner') unless owner.class.respond_to?(:effective_memberships_owner?)
+    raise('expecting a membership category') unless Array(to).all? { |to| to.class.respond_to?(:effective_memberships_category?) }
+
+    # Just a simple number right now
+    number = (Effective::Membership.all.max_number || 0) + 1
+
+    # Returns a string
+    number.to_s
+  end
+
+  def current_period
+    period(date: Time.zone.now)
+  end
+
+  # Returns a date of Jan 1, Year
+  def period(date:)
+    cutoff = renewal_fee_date(date: date) # period_end_on
+    period = (date < cutoff) ? date.beginning_of_year : date.advance(years: 1).beginning_of_year
+    period.to_date
+  end
+
+  def period_end_on(date:)
+    period(date: date).end_of_year
+  end
+
+  # This is intended to be run once per day in a rake task
+  # Create Renewal and Late fees
+  def create_fees!(period: nil, late_on: nil, bad_standing_on: nil)
+    # The current period, based on Time.zone.now
+    period ||= current_period
+    late_on ||= late_fee_date(period: period)
+    bad_standing_on ||= bad_standing_date(period: period)
+
+    # Create Renewal Fees
+    Effective::Membership.create_renewal_fees(period).find_each do |membership|
+      membership.categories.select(&:create_renewal_fees?).map do |category|
+        fee = membership.owner.build_renewal_fee(category: category, period: period, late_on: late_on, bad_standing_on: bad_standing_on)
+        raise("expected build_renewal_fee to return a fee for period #{period}") unless fee.kind_of?(Effective::Fee)
+        next if fee.purchased?
+
+        fee.save!
+      end
+    end
+
+    GC.start
+
+    # Create Late Fees
+    Effective::Membership.create_late_fees(period).find_each do |membership|
+      membership.categories.select(&:create_late_fees?).map do |category|
+        fee = membership.owner.build_late_fee(category: category, period: period)
+        next if fee.blank? || fee.purchased?
+
+        fee.save!
+      end
+    end
+
+    GC.start
+
+    # Update Membership Status - Assign In Bad Standing
+    Effective::Membership.deep.with_unpaid_fees_through(period).find_each do |membership|
+      membership.owner.update_membership_status!
+    end
+
+    true
+  end
+
+  # Called in the after_purchase of fee payment
+  def fee_payment_purchased!(owner)
+    raise('expecting a memberships owner') unless owner.class.respond_to?(:effective_memberships_owner?)
+    owner.update_membership_status!
+  end
+
+  protected
+
+  def save!(owner, date: Time.zone.now)
+    owner.build_membership_history(start_on: date)
+    owner.save!
+  end
+
+end

data/app/models/effective/applicant.rb

@@ -0,0 +1,7 @@
+module Effective
+  class Applicant < ActiveRecord::Base
+    self.table_name = EffectiveMemberships.applicants_table_name.to_s
+
+    effective_memberships_applicant
+  end
+end

data/app/models/effective/applicant_course.rb

@@ -0,0 +1,40 @@
+module Effective
+  class ApplicantCourse < ActiveRecord::Base
+    log_changes(to: :applicant) if respond_to?(:log_changes)
+
+    belongs_to :applicant_course_area
+
+    belongs_to :applicant_course_name, optional: true
+    belongs_to :applicant, optional: true
+
+    effective_resource do
+      title          :string
+      amount         :integer
+
+      code           :string
+      description    :text
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:applicant_course_area, :applicant_course_name, :applicant) }
+    scope :sorted, -> { order(:title) }
+
+    before_validation(if: -> { applicant_course_name.present? }) do
+      self.title = applicant_course_name.title
+      self.applicant_course_area = applicant_course_name.applicant_course_area
+    end
+
+    validates :title, presence: true
+
+    with_options(if: -> { applicant_course_name.blank? }) do
+      validates :code, presence: true
+      validates :description, presence: true
+    end
+
+    def to_s
+      title || 'course'
+    end
+
+  end
+end

data/app/models/effective/applicant_course_area.rb

@@ -0,0 +1,31 @@
+module Effective
+  class ApplicantCourseArea < ActiveRecord::Base
+    log_changes if respond_to?(:log_changes)
+
+    has_rich_text :body
+
+    has_many :applicant_course_names, dependent: :delete_all
+    accepts_nested_attributes_for :applicant_course_names
+
+    effective_resource do
+      title          :string
+      position       :integer
+
+      timestamps
+    end
+
+    scope :deep, -> { with_rich_text_body }
+    scope :sorted, -> { order(:position) }
+
+    before_validation do
+      self.position ||= (self.class.pluck(:position).compact.max || -1) + 1
+    end
+
+    validates :title, presence: true, uniqueness: true
+
+    def to_s
+      title || 'course area'
+    end
+
+  end
+end

data/app/models/effective/applicant_course_name.rb

@@ -0,0 +1,29 @@
+module Effective
+  class ApplicantCourseName < ActiveRecord::Base
+    log_changes(to: :applicant_course_area) if respond_to?(:log_changes)
+
+    belongs_to :applicant_course_area
+
+    effective_resource do
+      title          :string
+      position       :integer
+
+      timestamps
+    end
+
+    scope :deep, -> { all }
+    scope :sorted, -> { order(:position) }
+
+    before_validation(if: -> { applicant_course_area.present? }) do
+      self.position ||= (applicant_course_area.applicant_course_names.map(&:position).compact.max || -1) + 1
+    end
+
+    validates :title, presence: true, uniqueness: true
+    validates :position, presence: true
+
+    def to_s
+      title || 'course name'
+    end
+
+  end
+end

data/app/models/effective/applicant_education.rb

@@ -0,0 +1,36 @@
+module Effective
+  class ApplicantEducation < ActiveRecord::Base
+    belongs_to :applicant
+
+    log_changes(to: :applicant) if respond_to?(:log_changes)
+
+    effective_resource do
+      start_on       :date
+      end_on         :date
+
+      institution       :string
+      location          :string
+
+      degree_obtained   :string
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:applicant) }
+
+    validates :start_on, presence: true
+    validates :end_on, presence: true
+    validates :institution, presence: true
+    validates :location, presence: true
+    validates :degree_obtained, presence: true
+
+    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
+      degree_obtained || 'education'
+    end
+
+  end
+end