effective_memberships 0.3.13 → 0.4.1

data/app/models/concerns/effective_memberships_applicant.rb

@@ -44,7 +44,8 @@ module EffectiveMembershipsApplicant
     acts_as_wizard(
       start: 'Start',
       select: 'Select Application Type',
-      demographics: 'Demographics',
+      demographics: 'Demographics',         # Individual only. Users fields.
+      organization: 'Organization',         # Organization only. Organization fields.
       education: 'Education',
       course_amounts: 'Courses',
       experience: 'Work Experience',
@@ -73,8 +74,11 @@ module EffectiveMembershipsApplicant
     attr_accessor :approved_membership_date
 
     # Application Namespace
-    belongs_to :owner, polymorphic: true
-    accepts_nested_attributes_for :owner
+    belongs_to :user, polymorphic: true
+    accepts_nested_attributes_for :user
+
+    belongs_to :organization, polymorphic: true, optional: true
+    accepts_nested_attributes_for :organization
 
     belongs_to :category, polymorphic: true, optional: true
     belongs_to :from_category, polymorphic: true, optional: true
@@ -142,7 +146,7 @@ module EffectiveMembershipsApplicant
       timestamps
     end
 
-    scope :deep, -> { includes(:owner, :category, :from_category, :orders) }
+    scope :deep, -> { includes(:user, :organization, :category, :from_category, :orders) }
     scope :sorted, -> { order(:id) }
 
     scope :in_progress, -> { where.not(status: [:approved, :declined]) }
@@ -150,14 +154,15 @@ module EffectiveMembershipsApplicant
 
     scope :not_draft, -> { where.not(status: :draft) }
 
-    # Set Apply to Join or Reclassification
-    before_validation(if: -> { new_record? && owner.present? }) do
-      self.applicant_type ||= (owner.membership.blank? ? 'Apply to Join' : 'Apply to Reclassify')
-      self.from_category ||= owner.membership&.category
-    end
+    scope :for, -> (user) {
+      raise('expected a effective memberships user') unless user.class.try(:effective_memberships_user?)
+      where(user: user).or(where(organization: user.organizations))
+    }
 
-    before_validation(if: -> { current_step == :select && category_id.present? }) do
-      self.category_type ||= EffectiveMemberships.Category.name
+    # Set Apply to Join or Reclassification
+    before_validation(if: -> { (new_record? || current_step == :select) && owner.present? }) do
+      self.applicant_type = (owner.membership.blank? ? 'Apply to Join' : 'Apply to Reclassify')
+      self.from_category = owner.membership&.category
     end
 
     before_validation(if: -> { current_step == :experience }) do
@@ -165,18 +170,16 @@ module EffectiveMembershipsApplicant
     end
 
     # All Steps validations
-    validates :owner, presence: true
+    validates :user, presence: true
     validates :from_category, presence: true, if: -> { reclassification? }
 
     validate(if: -> { reclassification? }) do
       errors.add(:category_id, "can't reclassify to existing category") if category_id == from_category_id
     end
 
-    # Start Step
-    with_options(if: -> { current_step == :start && owner.present? }) do
-      validate do
-        errors.add(:base, 'may not have outstanding fees') if owner.outstanding_fee_payment_fees.present?
-      end
+    validate(if: -> { category.present? }) do
+      self.errors.add(:organization_id, "can't be blank when organization category") if category.organization? && organization.blank?
+      self.errors.add(:organization_id, "must be blank when individual category") if category.individual? && organization.present?
     end
 
     # Select Step
@@ -185,6 +188,10 @@ module EffectiveMembershipsApplicant
       validates :category, presence: true
     end
 
+    validate(if: -> { current_step == :select && owner.present? }) do
+      self.errors.add(:base, 'may not have outstanding fees') if owner.outstanding_fee_payment_fees.present?
+    end
+
     # Applicant Educations Step
     with_options(if: -> { current_step == :education }) do
       validate do
@@ -291,6 +298,14 @@ module EffectiveMembershipsApplicant
 
         # Special logic for stamp step
         applicant_steps.delete(:stamp) unless apply_to_join?
+        applicant_steps.delete(:organization) unless category&.organization?
+
+        # change_wizard_steps is defined in effective_resources acts_as_wizard
+        applicant_steps = change_wizard_steps(applicant_steps)
+
+        unless applicant_steps.kind_of?(Array) && applicant_steps.all? { |step| step.kind_of?(Symbol) }
+          raise('expected change_wizard_steps to return an Array of steps with no nils')
+        end
 
         wizard_steps.select do |step|
           required_steps.include?(step) || category.blank? || applicant_steps.include?(step)
@@ -370,6 +385,18 @@ module EffectiveMembershipsApplicant
     end
   end
 
+  def owner
+    organization || user
+  end
+
+  def owner_symbol
+    organization? ? :organization : :user
+  end
+
+  def build_organization(params = {})
+    self.organization = EffectiveMemberships.Organization.new(params)
+  end
+
   def apply_to_join?
     applicant_type == 'Apply to Join'
   end
@@ -378,8 +405,12 @@ module EffectiveMembershipsApplicant
     applicant_type == 'Apply to Reclassify'
   end
 
-  def owner_label
-    owner_type.to_s.split('::').last
+  def individual?
+    !(owner.kind_of?(EffectiveMemberships.Organization) && category&.organization?)
+  end
+
+  def organization?
+    owner.kind_of?(EffectiveMemberships.Organization) && category&.organization?
   end
 
   def in_progress?
@@ -399,9 +430,11 @@ module EffectiveMembershipsApplicant
     when 'draft'
       "Applicant has not yet completed the #{category} wizard steps or paid to submit this application. This application will transition to 'submitted' after payment has been collected."
     when 'submitted'
-      summary = "Application has been purchased and submitted. The following tasks must be done before this application will transition to 'completed':"
+      summary = "Application has been purchased and submitted."
+      tasks = "The following tasks remain before it can be completed:"
+      approval = "Waiting on approval."
       items = completed_requirements.map { |item, done| "<li>#{item}: #{done ? 'Complete' : 'Incomplete'}</li>" }.join
-      "<p>#{summary}</p><ul>#{items}</ul>"
+      completed_requirements.present? ? "<p>#{summary} #{tasks}</p><ul>#{items}</ul>" : "#{summary} #{approval}"
     when 'completed'
       if applicant_reviews_required?
         "All required materials have been provided. This application will transition to 'reviewed' after all reviewers have voted."
@@ -425,11 +458,11 @@ module EffectiveMembershipsApplicant
   def can_apply_categories_collection
     categories = EffectiveMemberships.Category.sorted.can_apply
 
-    if owner.blank? || owner.membership.blank?
+    if user.blank? || !user.is?(:member)
       return categories.where(can_apply_new: true)
     end
 
-    category_ids = owner.membership.category_ids
+    category_ids = user.memberships.map(&:category_ids).flatten
 
     categories.select do |cat|
       cat.can_apply_existing? ||
@@ -503,10 +536,6 @@ module EffectiveMembershipsApplicant
     )
   end
 
-  # The submit! method used to be here
-  # But it needs to be inside the included do block
-  # So see above. Sorry.
-
   def applicant_references_required?
     min_applicant_references > 0
   end
@@ -514,9 +543,13 @@ module EffectiveMembershipsApplicant
   # When an application is submitted, these must be done to go to completed.
   # An Admin can override this and just set them to completed.
   def completed_requirements
-    {
-      'Applicant References' => (!applicant_references_required? || applicant_references.count(&:completed?) >= min_applicant_references)
-    }
+    if category&.applicant_wizard_steps&.include?(:references) || applicant_references_required?
+      {
+        'Applicant References' => (!applicant_references_required? || applicant_references.count(&:completed?) >= min_applicant_references)
+      }
+    else
+      {}
+    end
   end
 
   def complete!

data/app/models/concerns/effective_memberships_category.rb

@@ -16,6 +16,10 @@ module EffectiveMembershipsCategory
   module ClassMethods
     def effective_memberships_category?; true; end
 
+    def category_types
+      ['Individual', 'Organization']
+    end
+
     def categories
       []
     end
@@ -35,6 +39,8 @@ module EffectiveMembershipsCategory
     has_many :membership_categories, class_name: 'Effective::MembershipCategory', as: :category
 
     effective_resource do
+      category_type         :string
+
       title                 :string
       category              :string
       position              :integer
@@ -110,17 +116,18 @@ module EffectiveMembershipsCategory
     scope :create_bad_standing, -> { where(create_bad_standing: true) }
 
     validates :title, presence: true, uniqueness: true
-
+    validates :category_type, presence: 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
+    before_validation do
+      self.applicant_wizard_steps = EffectiveMemberships.Applicant.all_wizard_steps if applicant_wizard_steps.blank?
+      self.applicant_review_wizard_steps = EffectiveMemberships.ApplicantReview.all_wizard_steps if applicant_review_wizard_steps.blank?
+      self.fee_payment_wizard_steps = EffectiveMemberships.FeePayment.all_wizard_steps if fee_payment_wizard_steps.blank?
     end
 
     before_validation do
       self.position ||= (self.class.pluck(:position).compact.max || -1) + 1
+      self.category_type ||= self.class.category_types.first
     end
 
     with_options(if: -> { can_apply? }) do
@@ -155,6 +162,14 @@ module EffectiveMembershipsCategory
     can_apply_new? || can_apply_existing? || can_apply_restricted?
   end
 
+  def individual?
+    category_type == 'Individual'
+  end
+
+  def organization?
+    category_type == 'Organization'
+  end
+
   def prorated_fee(date:)
     send("prorated_#{date.strftime('%b').downcase}").to_i
   end
@@ -167,6 +182,18 @@ module EffectiveMembershipsCategory
     Array(self[:can_apply_restricted_ids]) - [nil, '']
   end
 
+  def optional_applicant_wizard_steps
+    applicant_wizard_steps - EffectiveMemberships.Applicant.required_wizard_steps
+  end
+
+  def optional_fee_payment_wizard_steps
+    fee_payment_wizard_steps - EffectiveMemberships.FeePayment.required_wizard_steps
+  end
+
+  def optional_applicant_review_wizard_steps
+    applicant_review_wizard_steps - EffectiveMemberships.ApplicantReview.required_wizard_steps
+  end
+
   def applicant_wizard_steps
     (Array(self[:applicant_wizard_steps]) - [nil, '']).map(&:to_sym)
   end

data/app/models/concerns/effective_memberships_fee_payment.rb

@@ -32,7 +32,8 @@ module EffectiveMembershipsFeePayment
 
     acts_as_wizard(
       start: 'Start',
-      demographics: 'Demographics',
+      demographics: 'Demographics',         # Individual only. Users fields.
+      organization: 'Organization',         # Organization only. Organization fields.
       declarations: 'Declarations',
       summary: 'Review',
       billing: 'Billing Address',
@@ -48,23 +49,20 @@ module EffectiveMembershipsFeePayment
     attr_accessor :declare_code_of_ethics
     attr_accessor :declare_truth
 
-    # Throwaway
-    attr_accessor :upgrade, :downgrade
-
     # Application Namespace
-    belongs_to :owner, polymorphic: true
-    accepts_nested_attributes_for :owner
-
-    belongs_to :user, polymorphic: true, optional: true
+    belongs_to :user, polymorphic: true
     accepts_nested_attributes_for :user
 
+    belongs_to :organization, polymorphic: true, optional: true
+    accepts_nested_attributes_for :organization
+
     # Like maybe optionally it makes sense.
     belongs_to :category, polymorphic: true, optional: true
 
+    # Effective Namespace
     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
 
@@ -83,24 +81,32 @@ module EffectiveMembershipsFeePayment
       timestamps
     end
 
-    scope :deep, -> { includes(:owner, :category, :orders) }
+    scope :deep, -> { includes(:user, :organization, :category, :orders) }
     scope :sorted, -> { order(:id) }
 
     scope :in_progress, -> { where.not(status: [:submitted]) }
     scope :done, -> { where(status: [:submitted]) }
 
+    scope :for, -> (user) {
+      raise('expected a effective memberships user') unless user.class.try(:effective_memberships_user?)
+      where(user: user).or(where(organization: user.organizations))
+    }
+
     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
+    before_validation(if: -> { new_record? || current_step == :start }) do
+      self.organization_type = (EffectiveMemberships.Organization.name if organization_id.present?)
     end
 
-    validates :period, presence: true
+    before_validation(if: -> { current_step == :start && user && user.membership }) do
+      self.category ||= user.membership.categories.first if user.membership.categories.length == 1
+    end
 
     # All Steps validations
-    validates :owner, presence: true
+    validates :user, presence: true
+    validates :period, presence: true
 
     # Declarations Step
     with_options(if: -> { current_step == :declarations }) do
@@ -121,6 +127,9 @@ module EffectiveMembershipsFeePayment
 
         fee_payment_steps = Array(category&.fee_payment_wizard_steps)
 
+        fee_payment_steps.delete(:organization) unless organization?
+
+
         wizard_steps.select do |step|
           required_steps.include?(step) || category.blank? || fee_payment_steps.include?(step)
         end
@@ -129,10 +138,6 @@ module EffectiveMembershipsFeePayment
 
     # All Fees and Orders
     # Overriding acts_as_purchasable_wizard
-    def outstanding_fees
-      owner&.outstanding_fee_payment_fees
-    end
-
     def submit_fees
       fees
     end
@@ -143,7 +148,7 @@ module EffectiveMembershipsFeePayment
 
     # We take over the owner's outstanding fees.
     def find_or_build_submit_fees
-      Array(outstanding_fees).each { |fee| fees << fee unless fees.include?(fee) }
+      Array(owner.outstanding_fee_payment_fees).each { |fee| fees << fee unless fees.include?(fee) }
       submit_fees
     end
 
@@ -157,6 +162,26 @@ module EffectiveMembershipsFeePayment
     'Fee Payment'
   end
 
+  def owner
+    organization || user
+  end
+
+  def owner_symbol
+    organization? ? :organization : :user
+  end
+
+  def build_organization(params = {})
+    self.organization = EffectiveMemberships.Organization.new(params)
+  end
+
+  def individual?
+    !owner.kind_of?(EffectiveMemberships.Organization)
+  end
+
+  def organization?
+    owner.kind_of?(EffectiveMemberships.Organization)
+  end
+
   # Instance Methods
   def in_progress?
     draft?
@@ -175,30 +200,4 @@ module EffectiveMembershipsFeePayment
     save!
   end
 
-  # Work with effective_organizations
-  def organization!
-    if upgrade_individual_to_organization?
-      save!
-      update!(owner: owner.representatives.first.organization)
-    elsif downgrade_organization_to_individual?
-      save!
-      update!(owner: current_user)
-    else
-      save!
-    end
-  end
-
-  def upgrade_individual_to_organization?
-    return false unless EffectiveResources.truthy?(upgrade)
-    return false unless owner.class.respond_to?(:effective_organizations_user?)
-    owner.representatives.any?(&:new_record?)
-  end
-
-  def downgrade_organization_to_individual?
-    return false unless EffectiveResources.truthy?(downgrade)
-    return false unless owner.class.respond_to?(:effective_organizations_organization?)
-    return false if current_user.blank?
-    owner.representatives.any?(&:marked_for_destruction?)
-  end
-
 end

data/app/models/concerns/effective_memberships_organization.rb

@@ -0,0 +1,94 @@
+# EffectiveMembershipsOrganization
+#
+# Mark your category model with effective_memberships_organization to get all the includes
+
+module EffectiveMembershipsOrganization
+  extend ActiveSupport::Concern
+
+  module Base
+    def effective_memberships_organization
+      include ::EffectiveMembershipsOrganization
+    end
+  end
+
+  module ClassMethods
+    def effective_memberships_organization?; true; end
+
+    def categories
+      []
+    end
+  end
+
+  included do
+    effective_memberships_owner
+
+    acts_as_addressable :billing # effective_addresses
+    log_changes(except: [:representatives, :users]) if respond_to?(:log_changes)
+
+    # rich_text_body
+    # has_many_rich_texts
+
+    # App scoped
+    has_many :applicants, -> { order(:id) }, inverse_of: :organization, as: :organization
+    has_many :fee_payments, -> { order(:id) }, inverse_of: :organization, as: :organization
+
+    # Effective scoped
+    has_many :representatives, -> { Effective::Representative.sorted },
+      class_name: 'Effective::Representative', inverse_of: :organization, dependent: :delete_all
+
+    accepts_nested_attributes_for :representatives, allow_destroy: true
+
+    effective_resource do
+      title                 :string
+      email                 :string
+
+      phone                 :string
+      fax                   :string
+      website               :string
+
+      category              :string
+
+      notes                 :text
+
+      roles_mask            :integer
+      archived              :boolean
+
+      representatives_count :integer # Counter cache
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:representatives) }
+    scope :sorted, -> { order(:title) }
+
+    validates :title, presence: true, uniqueness: true
+    validates :email, presence: true
+  end
+
+  # Instance Methods
+  def to_s
+    title.presence || 'organization'
+  end
+
+  def membership_present?
+    membership.present? && !membership.marked_for_destruction?
+  end
+
+  def outstanding_fee_payment_fees
+    fees.select { |fee| fee.fee_payment_fee? && !fee.purchased? }
+  end
+
+  def representative(user:)
+    representatives.find { |rep| rep.user_id == user.id }
+  end
+
+  # Find or build
+  def build_representative(user:)
+    representative(user: user) || representatives.build(user: user)
+  end
+
+  def users
+    representatives.reject(&:marked_for_destruction?).map(&:user)
+  end
+
+end

data/app/models/concerns/effective_memberships_owner.rb

@@ -23,10 +23,6 @@ module EffectiveMembershipsOwner
   included do
     acts_as_role_restricted unless respond_to?(:acts_as_role_restricted?)
 
-    # App scoped
-    has_many :applicants, -> { order(:id) }, inverse_of: :owner, as: :owner
-    has_many :fee_payments, -> { order(:id) }, inverse_of: :owner, 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
@@ -40,48 +36,9 @@ module EffectiveMembershipsOwner
     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
-    raise('expected singular usage but there are more than one owner') if effective_memberships_owners.length > 1
-    effective_memberships_owners.first
-  end
-
-  def effective_memberships_owners
-    owners = organizations if self.class.respond_to?(:effective_organizations_user?)
-    owners = users if self.class.respond_to?(:effective_organizations_organization?)
-
-    owners = Array(owners)
-      .select { |owner| owner.class.respond_to?(:effective_memberships_owner?) }
-      .reject { |owner| owner.try(:archived?) }
-
-    owners.presence || [self]
-  end
-
-  # This is the calculated way of determining if an owner is a member or not.
-  # The correct way to check for membership is: current_user.is?(:member)
-  def membership_present?
-    individual_membership_present? || organization_membership_present?
-  end
-
-  def individual_membership_present?
-    membership.present? && !membership.marked_for_destruction?
-  end
-
-  def organization_membership_present?(except: nil)
-    return false unless self.class.respond_to?(:effective_organizations_user?)
-
-    organizations
-      .select { |organization| organization.class.respond_to?(:effective_memberships_owner?) }
-      .reject { |organization| organization.try(:archived?) }
-      .any? { |organization| organization != except && organization.membership_present? }
-  end
-
   def assign_member_role
     membership_present? ? add_role(:member) : remove_role(:member)
   end
@@ -92,18 +49,6 @@ module EffectiveMembershipsOwner
     save!
   end
 
-  def outstanding_fee_payment_owners
-    effective_memberships_owners.select { |owner| !owner.membership_fees_paid? }
-  end
-
-  def current_fee_payment_owner
-    outstanding_fee_payment_owners.first || 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

data/app/models/concerns/effective_memberships_registrar.rb

@@ -207,9 +207,10 @@ module EffectiveMembershipsRegistrar
     save!(owner, date: date)
   end
 
-  def fees_paid!(owner, date: nil)
+  def fees_paid!(owner, date: nil, order_attributes: nil)
     raise('expecting a memberships owner') unless owner.class.respond_to?(:effective_memberships_owner?)
     raise('expected a member') unless owner.membership.present?
+    raise('expected a Hash of attributes') if order_attributes.present? && !order_attributes.kind_of?(Hash)
 
     # Date
     date ||= Time.zone.now
@@ -219,6 +220,7 @@ module EffectiveMembershipsRegistrar
 
     if owner.outstanding_fee_payment_fees.present?
       order = Effective::Order.new(items: owner.outstanding_fee_payment_fees, user: owner)
+      order.assign_attributes(order_attributes) if order_attributes.present?
       order.mark_as_purchased!
     end
 
@@ -305,7 +307,7 @@ module EffectiveMembershipsRegistrar
   def add_member_role(owner)
     owner.add_role(:member)
 
-    if owner.class.respond_to?(:effective_organizations_organization?)
+    if owner.class.respond_to?(:effective_memberships_organization?)
       organization = owner
       organization.representatives.each { |representative| representative.user.add_role(:member) }
     end
@@ -316,7 +318,7 @@ module EffectiveMembershipsRegistrar
   def remove_member_role(owner)
     owner.remove_role(:member)
 
-    if owner.class.respond_to?(:effective_organizations_organization?)
+    if owner.class.respond_to?(:effective_memberships_organization?)
       organization = owner
 
       organization.representatives.each do |representative|