effective_events 0.19.2 → 0.20.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e67fe64e6e9affe8d6961f6bd8d6feea7f2795ee0f11087af84f896fe53457e
-  data.tar.gz: e43145e482ec697303b2aa0b6e0224f588339134b24259e8ee8c49f1c664e8a4
+  metadata.gz: 31dd5da1350e8c47f262ae186a59758c589747ad054bb2d9c73a766aab858673
+  data.tar.gz: 3523f02edb4b5e1e5144c4ae43686ab077a4873f0ce5346fb27429a05853e2de
 SHA512:
-  metadata.gz: b6cd3b5b07d8215f1e29ce434bfa19210d6ab8aa0ebfe8df4cf8a749b7732f76d97d1fb8863aa62a97853888c5915e7c76780624f4a2589edcc2efbe55858ea3
-  data.tar.gz: 84e7ba3b6ebc7dda5da0d751142acce2cc7dc95e93cf994a01dd427608d43516be81d5debac947b7fc975f8369ec6970e0982adbfa6d6661f2a6ce5bc3cd72af
+  metadata.gz: f5a012b7f897b93841d14080109278adc3d52231ffc9e0e5fc71c3379406d28cbf5ed6b11a3455eaeb8737b7065abc87ad78eea8b7441e16d34d886c919d00bd
+  data.tar.gz: 1f21df543c199fbb5f0cfb565b928d4d29405c731dc24dd8824baeb5b83e3436f63966100af4cefac0a1700757737e5e52f982a4ddc9e0ea36055186e5dac1fc

data/app/assets/javascripts/effective_events/base.js

@@ -0,0 +1,32 @@
+// For the Ticket Details screen
+$(document).on('select2:select', '[data-event-registrant-user-search]', function(event) {
+  var data = event.params.data['data'];
+  var $form = $(event.currentTarget).closest('.event-registrant-user-fields')
+
+  // Set the organization_id
+  $form.find('input[type="hidden"][name$="[organization_id]"]').val(data.organization_id || '')
+  $form.find('input[type="hidden"][name$="[organization_type]"]').val(data.organization_type || '')
+
+  // Disable everything else
+  $form.find('input[name$="[first_name]"]').val(data.first_name || '').prop('disabled', true)
+  $form.find('input[name$="[last_name]"]').val(data.last_name || '').prop('disabled', true)
+  $form.find('input[name$="[email]"]').val(data.email || '').prop('disabled', true)
+
+  $form.find('select[name$="[organization_id]"]').val(data.organization_id || '').trigger('change').prop('disabled', true)
+  $form.find('input[name$="[company]"]').val(data.company || '').prop('disabled', true)
+});
+
+$(document).on('select2:unselect', '[data-event-registrant-user-search]', function(event) {
+  var $form = $(event.currentTarget).closest('.event-registrant-user-fields')
+
+  // Unset the organization_id
+  $form.find('input[type="hidden"][name$="[organization_id]"]').val('')
+
+  // Enable everything else
+  $form.find('input[name$="[first_name]"]').val('').prop('disabled', false)
+  $form.find('input[name$="[last_name]"]').val('').prop('disabled', false)
+  $form.find('input[name$="[email]"]').val('').prop('disabled', false)
+
+  $form.find('select[name$="[organization_id]"]').val('').trigger('change').prop('disabled', false)
+  $form.find('input[name$="[company]"]').val('').prop('disabled', false)
+});

data/app/controllers/effective/event_registrants_select2_ajax_controller.rb

@@ -0,0 +1,61 @@
+module Effective
+  class EventRegistrantsSelect2AjaxController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+
+    include Effective::Select2AjaxController
+
+    def users
+      authorize! :users, Effective::EventRegistrant
+
+      with_organizations = current_user.class.try(:effective_memberships_organization_user?)
+
+      collection = current_user.class.all
+      collection = collection.includes(:organizations) if with_organizations
+
+      respond_with_select2_ajax(collection, skip_authorize: true) do |user|
+        data = { first_name: user.first_name, last_name: user.last_name, email: user.email }
+
+        if with_organizations
+          data[:company] = user.organizations.first.try(:to_s)
+          data[:organization_id] = user.organizations.first.try(:id)
+          data[:organization_type] = user.organizations.first.try(:class).try(:name)
+        end
+
+        { 
+          id: user.to_param, 
+          text: to_select2(user, with_organizations),
+          data: data
+        }
+      end
+    end
+
+    def organizations
+      raise('expected EffectiveEvents.organization_enabled?') unless EffectiveEvents.organization_enabled?
+
+      klass = EffectiveMemberships.Organization
+      raise('an EffectiveMemberships.Organization is required') unless klass.try(:effective_memberships_organization?)
+
+      collection = klass.all
+
+      # Authorize
+      EffectiveResources.authorize!(self, :member_organizations, collection.klass)
+
+      respond_with_select2_ajax(collection, skip_authorize: true) do |organization|
+        { id: organization.to_param, text: organization.to_s }
+      end
+    end
+
+    private
+
+    def to_select2(resource, with_organizations)
+      organizations = Array(resource.try(:organizations)).join(', ') if with_organizations
+
+      [
+        "<span>#{resource}</span>",
+        "<small>&lt;#{resource.try(:public_email).presence || resource.email}&gt;</small>",
+        ("<small>#{organizations}</small>" if organizations.present?)
+      ].compact.join(' ')
+    end
+
+  end
+end

data/app/controllers/effective/event_registrations_controller.rb

@@ -7,6 +7,7 @@ module Effective
     include Effective::WizardController
 
     before_action :redirect_unless_registerable, only: [:new, :show]
+    before_action :expire_ticket_selection_window, only: [:show]
 
     resource_scope -> {
       event = Effective::Event.find(params[:event_id])
@@ -18,12 +19,27 @@ module Effective
       return if resource.blank?
       return if resource.was_submitted?
       return if resource.event.blank?
-      return if resource.event.registerable?
       return if resource.submit_order&.deferred?
+      return if resource.event.registerable? && !resource.event.sold_out?(except: resource)
 
       flash[:danger] = "Your selected event is no longer available for registration. This event registration is no longer available."
       return redirect_to('/dashboard')
     end
 
+    def expire_ticket_selection_window
+      return if resource.blank?
+      return if resource.was_submitted?
+      return if resource.event.blank?
+      return if resource.selection_not_expired?
+
+      resource.ticket_selection_expired!
+
+      flash[:danger] = "Your ticket reservation window has expired. Your tickets are no longer reserved. Please start over."
+
+      return redirect_to(wizard_path(:start))
+    end
+
+    # TODO: Add better permitted params
+
   end
 end

data/app/datatables/admin/effective_event_registrants_datatable.rb

@@ -2,6 +2,7 @@ module Admin
   class EffectiveEventRegistrantsDatatable < Effective::Datatable
     filters do
       scope :unarchived, label: "All"
+      scope :registered
       scope :purchased
       scope :deferred
       scope :not_purchased
@@ -56,7 +57,7 @@ module Admin
       end
       
       col :user, label: 'Member', visible: false
-      col :member_or_non_member_choice, visible: false
+      col :organization, visible: false
 
       col :orders, visible: false
       col :price, as: :price

data/app/datatables/effective_event_registrants_datatable.rb

@@ -6,8 +6,11 @@ class EffectiveEventRegistrantsDatatable < Effective::Datatable
 
     col :name do |er|
       if er.first_name.present?
-        email = (er.user.present? ? masked_email(er.user) : er.email)
-        "#{er.first_name} #{er.last_name}<br><small>#{email}</small>"
+        [
+          "#{er.first_name} #{er.last_name}",
+          ("<small>#{er.organization || er.company}</small>" if er.organization || er.company.present?),
+          ("<small>#{er.email}</small>" if er.email.present?)
+        ].compact.join('<br>').html_safe
       elsif er.owner.present?
         er.owner.to_s + ' - GUEST'
       else
@@ -18,14 +21,12 @@ class EffectiveEventRegistrantsDatatable < Effective::Datatable
     col :id, visible: false
 
     col :event_ticket, search: :string, label: 'Ticket' do |er|
-      [
-        er.event_ticket.to_s,
-        (content_tag(:span, 'Waitlist', class: 'badge badge-warning') if er.waitlisted_not_promoted?),
-        (content_tag(:span, 'Archived', class: 'badge badge-warning') if er.event_ticket&.archived?)
-      ].compact.join('<br>').html_safe
+      [er.event_ticket.to_s, er.details.presence].compact.join('<br>').html_safe
     end
 
     col :user, label: 'Member', visible: false
+    col :organization, visible: false
+
     col :first_name, visible: false
     col :last_name, visible: false
     col :email, visible: false
@@ -35,14 +36,13 @@ class EffectiveEventRegistrantsDatatable < Effective::Datatable
     col :response2, visible: false
     col :response3, visible: false
 
-    col :details do |registrant|
+    col :responses, label: 'Details' do |registrant|
       [registrant.response1.presence, registrant.response2.presence, registrant.response3.presence].compact.map do |response|
         content_tag(:div, response)
       end.join.html_safe
     end
 
-    # This is the non-waitlisted full price
-    col :event_ticket_price, as: :price, label: 'Price'
+    col :price, as: :price
     col :archived, visible: false
 
     # no actions_col
@@ -56,7 +56,7 @@ class EffectiveEventRegistrantsDatatable < Effective::Datatable
     end
 
     if event_registration.present?
-      scope = scope.where(event_registration_id: event_registration)
+      scope = scope.where(event_registration_id: event_registration).sorted
     end
 
     scope

data/app/datatables/effective_event_registrations_datatable.rb

@@ -17,6 +17,7 @@ class EffectiveEventRegistrationsDatatable < Effective::Datatable
     col :owner, visible: false, search: :string
     col :status, visible: false
     col :event_registrants, label: 'Registrants', search: :string
+
     col :event_addons, label: 'Add-ons', search: :string
     col :orders, action: :show, visible: false, search: :string
 
@@ -31,7 +32,7 @@ class EffectiveEventRegistrationsDatatable < Effective::Datatable
         end
 
         # Register Again
-        if er.event.registerable?
+        if er.event.registerable? && !er.event.sold_out?
           url = er.event.external_registration_url.presence || effective_events.new_event_event_registration_path(er.event)
           dropdown_link_to('Register Again', url)
         end

data/app/helpers/effective_events_helper.rb

@@ -52,6 +52,8 @@ module EffectiveEventsHelper
 
     tickets.map do |ticket|
       title = ticket.to_s
+      title = "#{title} (archived)" if ticket.archived?
+
       price = effective_events_ticket_price(event, ticket)
 
       label = [title, price].compact.join(' - ')
@@ -81,23 +83,4 @@ module EffectiveEventsHelper
     end
   end
 
-  def effective_events_event_registrant_user_collection(event_registrant)
-    raise("expected an Effective::EventRegistrant") unless event_registrant.kind_of?(Effective::EventRegistrant)
-
-    Array(event_registrant.event_registration&.event_ticket_member_users).map do |user|
-      ["<span>#{user}</span> <small>#{user.email}</small>", user.to_param]
-    end
-  end
-
-  def effective_events_event_registrant_user_hint
-    url = if current_user.class.try(:effective_memberships_organization_user?)
-      organization = current_user.membership_organizations.first || current_user.organizations.first
-      effective_memberships.edit_organization_path(organization, anchor: 'tab-representatives') if organization
-    end
-    
-    return if url.blank?
-
-    "Can't find the member you need? <a href='#{url}' target='blank'>Click here</a> to add them to your #{EffectiveResources.etd(EffectiveMemberships.Organization)}."
-  end
-
 end

data/app/mailers/effective/events_mailer.rb

@@ -8,7 +8,7 @@ module Effective
       raise('expected an Effective::EventRegistrant') unless resource.kind_of?(Effective::EventRegistrant)
 
       @assigns = assigns_for(resource)
-      mail(to: resource.member_email, **headers_for(resource, opts))
+      mail(to: resource.email, **headers_for(resource, opts))
     end
 
     protected

data/app/models/concerns/effective_events_event_registration.rb

@@ -15,12 +15,13 @@ module EffectiveEventsEventRegistration
 
   module ClassMethods
     def effective_events_event_registration?; true; end
+
+    def selection_window
+      30.minutes
+    end
   end
 
   included do
-    # Needs to be first up here. Before the acts_as_purchasable_parent one voids the order
-    around_destroy :around_destroy_deferred_event_registration, if: -> { submit_order&.deferred? }
-
     acts_as_purchasable_parent
     acts_as_tokened
 
@@ -33,6 +34,7 @@ module EffectiveEventsEventRegistration
     acts_as_wizard(
       start: 'Start',
       tickets: 'Tickets',
+      details: 'Ticket Details',
       addons: 'Add-ons',
       summary: 'Review',
       billing: 'Billing Address',
@@ -52,10 +54,13 @@ module EffectiveEventsEventRegistration
     # Effective Namespace
     belongs_to :event, class_name: 'Effective::Event'
 
-    has_many :event_registrants, -> { order(:id) }, class_name: 'Effective::EventRegistrant', inverse_of: :event_registration, dependent: :destroy
+    has_many :event_ticket_selections, -> { order(:id) }, class_name: 'Effective::EventTicketSelection', inverse_of: :event_registration, dependent: :destroy
+    accepts_nested_attributes_for :event_ticket_selections, reject_if: :all_blank, allow_destroy: true
+
+    has_many :event_registrants, -> { order(:event_ticket_id, :id) }, class_name: 'Effective::EventRegistrant', inverse_of: :event_registration, dependent: :destroy
     accepts_nested_attributes_for :event_registrants, reject_if: :all_blank, allow_destroy: true
 
-    has_many :event_addons, -> { order(:id) }, class_name: 'Effective::EventAddon', inverse_of: :event_registration, dependent: :destroy
+    has_many :event_addons, -> { order(:event_product_id, :id) }, class_name: 'Effective::EventAddon', inverse_of: :event_registration, dependent: :destroy
     accepts_nested_attributes_for :event_addons, reject_if: :all_blank, allow_destroy: true
 
     has_many :orders, -> { order(:id) }, as: :parent, class_name: 'Effective::Order', dependent: :nullify
@@ -83,9 +88,10 @@ module EffectiveEventsEventRegistration
       timestamps
     end
 
-    scope :deep, -> { 
+    scope :deep, -> {
       includes(:owner)
       .includes(event: [:rich_texts, event_products: :purchased_event_addons, event_tickets: :purchased_event_registrants])
+      .includes(event_ticket_selections: [:event_ticket])
       .includes(event_registrants: [event_ticket: :purchased_event_registrants])
       .includes(event_addons: [event_product: :purchased_event_addons])
     }
@@ -106,18 +112,32 @@ module EffectiveEventsEventRegistration
 
     # All Steps
     validate(if: -> { event.present? }) do
-      self.errors.add(:base, "cannot register for an external registration event") if event.external_registration?
+      errors.add(:base, "cannot register for an external registration event") if event.external_registration?
     end
 
     # Tickets Step
     validate(if: -> { current_step == :tickets }) do
-      self.errors.add(:event_registrants, "can't be blank") unless present_event_registrants.present?
+      if event_ticket_selections.all? { |selection| selection.quantity.to_i == 0 }
+        errors.add(:event_ticket_selections, "Please select one or more tickets")
+        event_ticket_selections.each { |ets| ets.errors.add(:quantity, "can't be blank") }
+      end
     end
 
     # Validate all tickets are available for registration
     validate(if: -> { current_step == :tickets }) do
       unavailable_event_tickets.each do |event_ticket|
         errors.add(:base, "The requested number of #{event_ticket} tickets are not available")
+        event_ticket_selections.find { |ets| ets.event_ticket == event_ticket }.errors.add(:quantity, "not available")
+      end
+    end
+
+    # Validate the same registrant user isn't being registered twice
+    validate(if: -> { current_step == :details }) do
+      present_event_registrants.group_by { |er| er.user }.each do |user, event_registrants|
+        if user.present? && event_registrants.length > 1
+          errors.add(:base, "Unable to register #{user} more than once")
+          event_registrants.each { |er| er.errors.add(:user_id, "cannot be registered more than once") }
+        end
       end
     end
 
@@ -131,19 +151,6 @@ module EffectiveEventsEventRegistration
     # If we're submitted. Try to move to completed.
     before_save(if: -> { submitted? }) { try_completed! }
 
-    def around_destroy_deferred_event_registration
-      raise('expecting a deferred submit order') unless submit_order&.deferred?
-
-      waitlisted_event_tickets_was = event_tickets().select(&:waitlist?)
-      yield
-      waitlisted_event_tickets_was.each { |event_ticket| event_ticket.update_waitlist! }
-      true
-    end
-
-    def delayed_payment_date_upcoming?
-      event&.delayed_payment_date_upcoming?
-    end
-
     def can_visit_step?(step)
       return false if step == :complete && !completed?
       return true if step == :complete && completed?
@@ -164,17 +171,24 @@ module EffectiveEventsEventRegistration
 
     def required_steps
       return self.class.test_required_steps if Rails.env.test? && self.class.test_required_steps.present?
-      event&.event_products.unarchived.present? ? wizard_step_keys : (wizard_step_keys - [:addons])
-    end
 
-    def find_or_build_submit_fees
-      with_outstanding_coupon_fees(submit_fees)
+      with_addons = event.event_products.any? { |event_product| event_product.archived? == false }
+
+      with_addons ? wizard_step_keys : (wizard_step_keys - [:addons])
     end
 
     def delayed_payment_attributes
       { delayed_payment: event&.delayed_payment, delayed_payment_date: event&.delayed_payment_date }
     end
 
+    def delayed_payment_date_upcoming?
+      event&.delayed_payment_date_upcoming?
+    end
+
+    def find_or_build_submit_fees
+      with_outstanding_coupon_fees(submit_fees)
+    end
+
     # All Fees and Orders
     def submit_fees
       if defined?(EffectiveMemberships)
@@ -217,7 +231,95 @@ module EffectiveEventsEventRegistration
     completed?
   end
 
+  def display_countdown?
+    return false if done?
+    return false unless selected_at.present?
+    return false unless current_step.present?
+
+    [:start, :tickets, :submitted, :complete].exclude?(current_step)
+  end
+
+  # When we make a ticket selection, we assign the selected_at to all tickets
+  # So the max or the min should be the same here.
+  def selected_at
+    event_registrants.map(&:selected_at).compact.max
+  end
+
+  def selected_expires_at
+    selected_at + EffectiveEvents.EventRegistration.selection_window
+  end
+
+  def selected_expired?
+    return false if selected_at.blank?
+    Time.zone.now >= selected_expires_at
+  end
+
+  def selection_not_expired?
+    return true if selected_at.blank?
+    Time.zone.now < selected_expires_at
+  end
+
+  # Called by a before_action on the event registration show action
+  def ticket_selection_expired!
+    raise("unexpected submitted registration") if was_submitted?
+    raise("unexpected purchased order") if submit_order&.purchased?
+    raise("unexpected deferred order") if submit_order&.deferred?
+
+    event_registrants.each { |er| er.assign_attributes(selected_at: nil) }
+    event_ticket_selections.each { |ets| ets.assign_attributes(quantity: 0) }
+    assign_attributes(current_step: nil, wizard_steps: {}) # Reset all steps
+
+    save!
+  end
+
+  # This considers the event_ticket_selection and builds the appropriate event_registrants
+  def update_event_registrants
+    event_ticket_selections.each do |event_ticket_selection|
+      event_ticket = event_ticket_selection.event_ticket
+      quantity = event_ticket_selection.quantity.to_i
+
+      # All the registrants for this event ticket
+      registrants = event_registrants.select { |er| er.event_ticket == event_ticket }
+
+      # Delete over quantity
+      if (diff = registrants.length - quantity) > 0
+        registrants.last(diff).each { |er| er.mark_for_destruction }
+      end
+
+      # Create upto quantity
+      if (diff = quantity - registrants.length) > 0
+        diff.times { build_event_registrant(event_ticket: event_ticket) }
+      end
+    end
+
+    event_registrants
+  end
+
+  # Assigns the selected at time to start the reservation window
+  def select_event_registrants
+    now = Time.zone.now
+    present_event_registrants.each { |er| er.assign_attributes(selected_at: now) }
+  end
+
+  # Looks at any unselected event registrants and assigns a waitlist value
+  def waitlist_event_registrants
+    present_event_registrants.group_by { |er| er.event_ticket }.each do |event_ticket, event_registrants|
+      if event_ticket.waitlist?
+        capacity = event.capacity_available(event_ticket: event_ticket, event_registration: self)
+        event_registrants.each_with_index { |er, index| er.assign_attributes(waitlisted: index >= capacity) }
+      else
+        event_registrants.each { |er| er.assign_attributes(waitlisted: false) }
+      end
+    end
+  end
+
   def tickets!
+    assign_attributes(current_step: :tickets) # Ensure the unavailable tickets validations are run
+
+    update_event_registrants
+    select_event_registrants
+    waitlist_event_registrants
+
     after_commit do
       update_submit_fees_and_order! if submit_order.present?
       update_deferred_event_registration! if submit_order&.deferred?
@@ -252,27 +354,26 @@ module EffectiveEventsEventRegistration
     true
   end
 
-  # Find or build
-  def event_registrant(event_ticket:, first_name:, last_name:, email:)
-    registrant = event_registrants.find { |er| er.event_ticket == event_ticket && er.first_name == first_name && er.last_name == last_name && er.email == email }
-    registrant || event_registrants.build(event: event, event_ticket: event_ticket, owner: owner, first_name: first_name, last_name: last_name, email: email)
+  def build_event_registrant(event_ticket:)
+    event_registrants.build(event: event, event_ticket: event_ticket, owner: owner)
   end
 
+  # Find or build - # Used for testing
+  # def event_registrant(event_ticket:, first_name:, last_name:, email:)
+  #   registrant = event_registrants.find { |er| er.event_ticket == event_ticket && er.first_name == first_name && er.last_name == last_name && er.email == email }
+  #   registrant || event_registrants.build(event: event, event_ticket: event_ticket, owner: owner, first_name: first_name, last_name: last_name, email: email)
+  # end
+
   # Find or build. But it's not gonna work with more than 1. This is for testing only really.
   def event_addon(event_product:, first_name:, last_name:, email:)
     addon = event_addons.find { |er| er.event_product == event_product && er.first_name == first_name && er.last_name == last_name && er.email == email }
     addon || event_addons.build(event: event, event_product: event_product, owner: owner, first_name: first_name, last_name: last_name, email: email)
   end
 
-  # This builds the default event registrants used by the wizard form
-  def build_event_registrants
-    if event_registrants.blank?
-      raise('expected owner and event to be present') unless owner && event
-
-      event_registrants.build()
-    end
-
-    event_registrants
+  # Find or build
+  def event_ticket_selection(event_ticket:, quantity: 0)
+    selection = event_ticket_selections.find { |ets| ets.event_ticket == event_ticket } 
+    selection || event_ticket_selections.build(event_ticket: event_ticket, quantity: quantity)
   end
 
   # This builds the default event addons used by the wizard form
@@ -298,9 +399,7 @@ module EffectiveEventsEventRegistration
     unavailable = []
 
     present_event_registrants.map(&:event_ticket).group_by { |t| t }.each do |event_ticket, event_tickets|
-      unless event_ticket.waitlist? || event.event_ticket_available?(event_ticket, quantity: event_tickets.length)
-        unavailable << event_ticket 
-      end
+      unavailable << event_ticket unless event.event_ticket_available?(event_ticket, except: self, quantity: event_tickets.length)
     end
 
     unavailable
@@ -316,13 +415,6 @@ module EffectiveEventsEventRegistration
     unavailable
   end
 
-  def event_ticket_member_users
-    raise("expected owner to be a user") if owner.class.try(:effective_memberships_organization?)
-    users = [owner] + (owner.try(:organizations).try(:flat_map, &:users) || [])
-
-    users.select { |user| user.is_any?(:member) }.uniq
-  end
-
   def update_blank_registrants!
     # This method is called by the user on a submitted or completed event registration.
     # Allow them to update blank registrants
@@ -343,6 +435,7 @@ module EffectiveEventsEventRegistration
       raise('unable to make changes to event addons while updating blank registrants')
     end
 
+    assign_attributes(current_step: :details) if current_step.blank? # Enables validations
     save!
 
     update_submit_fees_and_order! if submit_order.present? && !submit_order.purchased?
@@ -358,9 +451,6 @@ module EffectiveEventsEventRegistration
     # Mark registered anyone who hasn't been registered yet. They are now!
     event_registrants.reject(&:registered?).each { |event_registrant| event_registrant.registered! }
 
-    # Update the waitlist for any event tickets
-    event_tickets.select(&:waitlist?).each { |event_ticket| event_ticket.update_waitlist! }
-
     true
   end
 

data/app/models/effective/event.rb

@@ -15,7 +15,7 @@ module Effective
     has_many :event_products, -> { EventProduct.sorted }, inverse_of: :event, dependent: :destroy
     accepts_nested_attributes_for :event_products, allow_destroy: true
 
-    has_many :event_registrants, -> { order(:event_ticket_id).order(:id) }, inverse_of: :event
+    has_many :event_registrants, -> { order(:event_ticket_id, :id) }, inverse_of: :event
     accepts_nested_attributes_for :event_registrants, allow_destroy: true
 
     has_many :event_addons, -> { order(:event_product_id).order(:id) }, inverse_of: :event
@@ -190,11 +190,10 @@ module Effective
       event_tickets.any? { |et| et.waitlist? }
     end
 
+    # No longer includes sold_out? we check that separately
     def registerable?
       return false unless published?
       return false if closed?
-      return false if sold_out?
-
       (external_registration? && external_registration_url.present?) || event_tickets.present?
     end
 
@@ -203,10 +202,13 @@ module Effective
       registration_end_at < Time.zone.now
     end
 
-    def sold_out?
+    def sold_out?(except: nil)
+      raise('expected except to be an EventRegistration') if except && !except.class.try(:effective_events_event_registration?)
+
       return false unless event_tickets.present?
       return false if any_waitlist?
-      event_tickets.none? { |event_ticket| event_ticket_available?(event_ticket, quantity: 1) }
+
+      event_tickets.none? { |event_ticket| event_ticket_available?(event_ticket, except: except, quantity: 1) }
     end
 
     def early_bird?
@@ -250,19 +252,37 @@ module Effective
       start_at
     end
 
+    # The amount of tickets that can be purchased except ones from an event registration
+    def capacity_selectable(event_ticket:, event_registration: nil)
+      return 0 if event_ticket.archived?
+      return 100 if event_ticket.capacity.blank?
+      return 100 if event_ticket.waitlist?
+
+      event_ticket.capacity_selectable(except: event_registration)
+    end
+
+    # The amount of tickets that can be purchased except ones from an event registration
+    def capacity_available(event_ticket:, event_registration: nil)
+      event_ticket.capacity_available(except: event_registration)
+    end
+
+    # Just used in tests so far
+    def capacity_taken(event_ticket:, event_registration: nil)
+      event_ticket.capacity_taken(except: event_registration)
+    end
+
     # Can I register/purchase this many new event tickets?
-    def event_ticket_available?(event_ticket, quantity:)
+    def event_ticket_available?(event_ticket, except: nil, quantity: 0)
       raise('expected an EventTicket') unless event_ticket.kind_of?(Effective::EventTicket)
+      raise('expected except to be an EventRegistration') if except && !except.class.try(:effective_events_event_registration?)
       raise('expected quantity to be greater than 0') unless quantity.to_i > 0
 
       return false if event_ticket.archived?
-      return true if event_ticket.capacity.blank?   # No capacity enforced for this ticket
+      return true if event_ticket.capacity.blank? # No capacity enforced
+      return true if event_ticket.waitlist?       # Always available for waitlist
 
-      # Total number already sold
-      registered = registered_event_registrants.count { |r| r.event_ticket_id == event_ticket.id }
-
-      # If there's capacity for this many more
-      (registered + quantity) <= event_ticket.capacity
+      # Do we have any tickets available left?
+      event_ticket.capacity_available(except: except) >= quantity.to_i
     end
 
     # Can I register/purchase this many new event products?