effective_events 0.19.2 → 0.20.0

data/app/models/effective/event_registrant.rb

@@ -2,10 +2,13 @@
 
 module Effective
   class EventRegistrant < ActiveRecord::Base
+    include ActionView::Helpers::TagHelper
+
     self.table_name = (EffectiveEvents.event_registrants_table_name || :event_registrants).to_s
 
-    PERMITTED_BLANK_REGISTRANT_CHANGES = ["first_name", "last_name", "email", "company", "user_id", "user_type", "blank_registrant", "member_or_non_member_choice", "response1", "response2", "response3"]
-    MEMBER_OR_NON_MEMBER_CHOICES = ['Add a regular registration', 'Add a member registration']
+    PERMITTED_BLANK_REGISTRANT_CHANGES = ["first_name", "last_name", "email", "company", "user_id", "user_type", "organization_id", "organization_type", "blank_registrant", "response1", "response2", "response3"]
+
+    attr_accessor :building_user_and_organization
 
     acts_as_purchasable
     acts_as_archived
@@ -14,7 +17,7 @@ module Effective
 
     belongs_to :event, counter_cache: true
 
-    # Basically a category containing all the pricing and unique info about htis registrant
+    # Basically a category containing all the pricing and unique info about this registrant
     belongs_to :event_ticket
 
     # Every event registrant is charged to a owner
@@ -23,20 +26,26 @@ module Effective
     # This fee when checked out through the event registration
     belongs_to :event_registration, polymorphic: true, optional: true
 
-    # Required for member-only tickets. The user attending.
+    # The user for this registrant
     belongs_to :user, polymorphic: true, optional: true
+    accepts_nested_attributes_for :user
+
+    # The organization for this registrant
+    belongs_to :organization, polymorphic: true, optional: true
+    accepts_nested_attributes_for :organization
 
     effective_resource do
       first_name            :string
       last_name             :string
       email                 :string
-      company               :string
+      company               :string       # Organization name
 
-      blank_registrant             :boolean
-      member_or_non_member_choice  :string       # Used by Member or Non-Member tickets to indicate a member or non-member
+      blank_registrant      :boolean      # Leave details and come back later
 
       waitlisted            :boolean
       promoted              :boolean      # An admin marked this registrant as promoted from the waitlist
+
+      selected_at           :datetime     # When the event registration was selected by a user on the tickets! step
       registered_at         :datetime     # When the order is deferred or purchased
 
       # Question Responses
@@ -58,7 +67,7 @@ module Effective
       timestamps
     end
 
-    scope :sorted, -> { order(:last_name) }
+    scope :sorted, -> { order(:event_ticket_id, :id) }
     scope :deep, -> { includes(:event, :event_ticket, :owner) }
     scope :registered, -> { where.not(registered_at: nil) }
 
@@ -67,12 +76,31 @@ module Effective
       self.owner ||= event_registration.owner
     end
 
-    before_validation(if: -> { blank_registrant? }) do
-      assign_attributes(user: nil, first_name: nil, last_name: nil, email: nil, company: nil)
-    end
+    with_options(unless: -> { purchased? && !blank_registrant_was }) do
+      before_validation(if: -> { blank_registrant? }) do
+        assign_attributes(user: nil, organization: nil, first_name: nil, last_name: nil, email: nil, company: nil)
+      end
+
+      before_validation(if: -> { user.blank? }) do
+        assign_attributes(building_user_and_organization: true) # For member-only ticket validations
+      end
 
-    before_validation(if: -> { user.present? }) do
-      assign_attributes(first_name: user.first_name, last_name: user.last_name, email: user.email)
+      before_validation(if: -> { user.blank? && first_name.present? && last_name.present? && email.present? }) do
+        build_user() if EffectiveEvents.create_users
+        build_organization_and_representative() if EffectiveEvents.organization_enabled?
+      end
+
+      before_validation(if: -> { user.present? }) do
+        assign_attributes(first_name: user.first_name, last_name: user.last_name, email: (user.try(:public_email).presence || user.email))
+      end
+
+      before_validation(if: -> { organization.blank? && user.present? && user.class.try(:effective_memberships_organization_user?) }) do
+        assign_attributes(company: user.organizations.first.to_s.presence) if company.blank?
+      end
+
+      before_validation(if: -> { organization.present? }) do
+        assign_attributes(company: organization.to_s)
+      end
     end
 
     before_validation(if: -> { event_ticket.present? }, unless: -> { purchased? }) do
@@ -83,35 +111,44 @@ module Effective
       errors.add(:waitlisted, 'is not permitted for a non-waitlist event ticket') if waitlisted? && !event_ticket.waitlist?
     end
 
-    validates :user_id, uniqueness: { scope: [:event_id], allow_blank: true, message: 'is already registered for this event' }
     validates :price, presence: true, numericality: { greater_than_or_equal_to: 0 }
     validates :email, email: true
 
-    # Member Only Ticket
-    with_options(if: -> { event_ticket&.member_only? && present_registrant? }) do
-      validates :user_id, presence: { message: 'Please select a member' }
-    end
+    # This works for persisted and adding a new one. But not adding two at same time in a registration
+    validates :user_id, uniqueness: { scope: [:event_id], allow_blank: true, message: 'is already registered for this event' }
+
+    # First name, last name and email are always required fields on details
+    validates :first_name, presence: true, if: -> { registrant_validations_enabled? }
+    validates :last_name, presence: true, if: -> { registrant_validations_enabled? }
+    validates :email, presence: true, if: -> { registrant_validations_enabled? }
+
+    # User, company and organization conditionall required
+    validates :user, presence: true, if: -> { registrant_validations_enabled? && EffectiveEvents.create_users }
+    validates :company, presence: true, if: -> { registrant_validations_enabled? && EffectiveEvents.company_or_organization_required }
+    validates :organization, presence: true, if: -> { registrant_validations_enabled? && EffectiveEvents.company_or_organization_required && EffectiveEvents.organization_enabled? }
 
-    # Regular Ticket
-    with_options(if: -> { event_ticket&.regular? && present_registrant? }) do
-      validates :first_name, presence: true, unless: -> { EffectiveEvents.event_registrant_required_fields.exclude?(:first_name) }
-      validates :last_name, presence: true, unless: -> { EffectiveEvents.event_registrant_required_fields.exclude?(:last_name) }
-      validates :email, presence: true, unless: -> { EffectiveEvents.event_registrant_required_fields.exclude?(:email) }
-      validates :company, presence: true, unless: -> { EffectiveEvents.event_registrant_required_fields.exclude?(:company) }
+    # Member ticket: company name is locked in. you can only add to your own company
+    validate(if: -> { registrant_validations_enabled? && event_ticket&.member_only? }) do
+      if building_user_and_organization && owner.present? && Array(owner.try(:organizations)).exclude?(organization)
+        errors.add(:organization_id, "must be your own for member-only tickets") 
+      end
+
+      errors.add(:user_id, 'must be a member to register for member-only tickets') unless member_present?
     end
 
-    # Member or Non-Member Ticket
-    validates :member_or_non_member_choice, presence: true, if: -> { event_ticket&.member_or_non_member? && present_registrant? }
+    # Copy any user errors from build_user_and_organization() into the registrant
+    after_validation(if: -> { user && user.new_record? && user.errors.present? }) do
+      errors.add(:first_name, user.errors[:first_name].join(', ')) if user.errors[:first_name].present?
+      errors.add(:last_name, user.errors[:last_name].join(', ')) if user.errors[:last_name].present?
+      errors.add(:email, user.errors[:email].join(', ')) if user.errors[:email].present?
 
-    with_options(if: -> { event_ticket&.member_or_non_member? && present_registrant? && member_or_non_member_choice == 'Add a regular registration' }) do
-      validates :first_name, presence: true, unless: -> { EffectiveEvents.event_registrant_required_fields.exclude?(:first_name) }
-      validates :last_name, presence: true, unless: -> { EffectiveEvents.event_registrant_required_fields.exclude?(:last_name) }
-      validates :email, presence: true, unless: -> { EffectiveEvents.event_registrant_required_fields.exclude?(:email) }
-      validates :company, presence: true, unless: -> { EffectiveEvents.event_registrant_required_fields.exclude?(:company) }
+      others = user.errors.reject { |error| [:first_name, :last_name, :email].include?(error.attribute) }
+      errors.add(:base, others.map(&:full_message).join(', ')) if others.present?
     end
 
-    with_options(if: -> { event_ticket&.member_or_non_member? && present_registrant? && member_or_non_member_choice == 'Add a member registration' }) do
-      validates :user_id, presence: { message: 'Please select a member' }
+    # Copy any organization errors from build_user_and_organization() into the registrant
+    after_validation(if: -> { organization && organization.new_record? && organization.errors.present? }) do
+      errors.add(:company, organization.errors.full_messages.join(', '))
     end
 
     after_defer do
@@ -127,7 +164,7 @@ module Effective
     end
 
     def title
-      [event_ticket.to_s, name, ('WAITLIST' if waitlisted_not_promoted?)].compact.join(' - ')
+      ["#{event_ticket} - #{name}", details.presence].compact.join(' ').html_safe
     end
 
     def name
@@ -140,20 +177,42 @@ module Effective
       end
     end
 
+    def details
+      [
+        (content_tag(:span, 'Member', class: 'badge badge-warning') if member_ticket?),
+        (content_tag(:span, 'Waitlist', class: 'badge badge-warning') if waitlisted_not_promoted?),
+        (content_tag(:span, 'Archived', class: 'badge badge-warning') if event_ticket&.archived?)
+      ].compact.join(' ').html_safe
+    end
+
+    def purchasable_name
+      ["#{event_ticket} - #{name}", details.presence].compact.join('<br>').html_safe
+    end
+
     def last_first_name
-      first_name.present? ? "#{last_name}, #{first_name}" : "GUEST"
+      (first_name.present? && last_name.present?) ? "#{last_name}, #{first_name}" : "GUEST"
     end
 
-    def member_present?
-      user&.is?(:member)
+    # We create registrants on the tickets step. But don't enforce validations until the details step.
+    def registrant_validations_enabled?
+      return false if blank_registrant? # They want to come back later
+
+      return true if event_registration.blank? # If we're creating in an Admin area
+      return false if event_ticket.blank? # Invalid anyway
+
+      event_registration.current_step == :details
     end
 
-    def member_or_non_member_choice
-      self[:member_or_non_member_choice] || 'Add a regular registration'
+    def member_present?
+      user.try(:is?, :member) || organization.try(:is?, :member)
     end
 
-    def member_email
-      email.presence || user&.email
+    def member_ticket?
+      return false if event_ticket.blank?
+      return true if event_ticket.member_only?
+      return true if event_ticket.member_or_non_member? && member_present?
+
+      false
     end
 
     def present_registrant?
@@ -168,10 +227,19 @@ module Effective
       event_ticket&.qb_item_name
     end
 
+    def selected?
+      selected_at.present?
+    end
+
     def registered?
       registered_at.present?
     end
 
+    def selected_not_expired?
+      return false unless EffectiveEvents.EventRegistration.selection_window.present?
+      selected_at.present? && (selected_at + EffectiveEvents.EventRegistration.selection_window > Time.zone.now)
+    end
+
     # Called by an event_registration after_defer and after_purchase
     def registered!
       self.registered_at ||= Time.zone.now
@@ -219,10 +287,6 @@ module Effective
       true
     end
 
-    def registered?
-      registered_at.present?
-    end
-
     def event_ticket_price
       raise('expected an event') if event.blank?
       raise('expected an event ticket') if event_ticket.blank?
@@ -246,6 +310,68 @@ module Effective
 
     private
 
+    def build_user
+      raise('is already purchased') if purchased?
+      raise('expected no user') unless user.blank?
+      raise('expected a first_name') unless first_name.present?
+      raise('expected a last_name') unless last_name.present?
+      raise('expected a email') unless email.present?
+
+      return if user_type.blank?
+
+      # Add User
+      user_klass = user_type.constantize
+
+      # First we lookup the user by email. If they actually exist we ignore all other fields
+      existing_user = user_klass.find_by_any_email(email.strip.downcase)
+
+      if existing_user.present?
+        assign_attributes(user: existing_user)
+
+        if EffectiveEvents.organization_enabled? && user_klass.try(:effective_memberships_organization_user?)
+          assign_attributes(organization: existing_user.organizations.first) if existing_user.organizations.present?
+        end
+      else
+        # Otherwise create a new user
+        new_user = user_klass.create(
+          first_name: first_name.strip, 
+          last_name: last_name.strip, 
+          email: email.strip.downcase, 
+          password: SecureRandom.base64(12) + '!@#123abcABC-'
+        )
+
+        assign_attributes(user: new_user)
+      end
+
+      user.valid?
+    end
+
+    # The organization might already be set here
+    def build_organization_and_representative
+      raise('is already purchased') if purchased?
+
+      return if organization_type.blank?
+
+      # We previously created an invalid user
+      return if user.present? && user.errors.present?
+
+      # Add Organization and representative
+      organization_klass = organization_type.constantize
+
+      # Find or create the organization
+      if organization.present?
+        user.build_representative(organization: organization) if user.present?
+      elsif company.present?
+        new_organization = organization_klass.where(title: company.strip).first
+        new_organization ||= organization_klass.create(title: company.strip, email: email.strip.downcase)
+        assign_attributes(organization: new_organization)
+
+        user.build_representative(organization: new_organization) if user.present?
+      end
+
+      true
+    end
+
     def assign_price
       raise('is already purchased') if purchased?
 

data/app/models/effective/event_ticket.rb

@@ -69,35 +69,38 @@ module Effective
     validates :early_bird_price, numericality: { greater_than_or_equal_to: 0, allow_blank: true }
 
     validates :capacity, numericality: { greater_than_or_equal_to: 0, allow_blank: true }
+    validates :capacity, presence: { message: 'must be present when using the waitlist'}, if: -> { waitlist? }
 
     def to_s
       title.presence || 'New Event Ticket'
     end
 
-    # This is supposed to be an indempotent big update the world thing
-    def update_waitlist!
-      return false unless waitlist?
+    def capacity_selectable(except: nil)
+      return nil if capacity.blank?
+      return nil if waitlist?
 
-      changed_event_registrants = registered_event_registrants.each_with_index.map do |event_registrant, index|
-        next if event_registrant.purchased?
+      capacity_available(except: except)
+    end
 
-        waitlisted_was = event_registrant.waitlisted?
-        waitlisted = (waitlist? && index >= capacity)
-        next if waitlisted == waitlisted_was
+    def capacity_available(except: nil)
+      return nil if capacity.blank?
+      [(capacity - capacity_taken(except: except)), 0].max
+    end
 
-        event_registrant.update!(waitlisted: waitlisted) # Updates price
-        event_registrant
-      end.compact
+    def capacity_taken(except: nil)
+      registered_or_selected_event_registrants(except: except).reject(&:waitlisted?).length
+    end
 
-      orders = changed_event_registrants.flat_map { |event_registrant| event_registrant.deferred_orders }.compact.uniq
-      orders.each { |order| order.update_purchasable_attributes! }
+    def registered_or_selected_event_registrants(except: nil)
+      raise('expected except to be an EventRegistration') if except && !except.class.try(:effective_events_event_registration?)
 
-      true
+      event_registrants.select do |er| 
+        (er.registered? || er.selected_not_expired?) && (except.blank? || er.event_registration_id != except.id)
+      end
     end
 
-    def capacity_available
-      return nil if capacity.blank?
-      [(capacity - registered_event_registrants_count), 0].max
+    def registered_or_selected_event_registrants_count
+      registered_or_selected_event_registrants.count
     end
 
     def registered_event_registrants_count

data/app/models/effective/event_ticket_selection.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Form object to select a # of tickets on the EventRegistration form
+
+module Effective
+  class EventTicketSelection < ActiveRecord::Base
+    self.table_name = (EffectiveEvents.event_ticket_selections_table_name || :event_ticket_selections).to_s
+
+    belongs_to :event_registration, polymorphic: true
+    belongs_to :event_ticket
+
+    effective_resource do
+      quantity        :integer
+
+      timestamps
+    end
+
+    scope :sorted, -> { order(:id) }
+    scope :deep, -> { includes(:event_registration, :event_ticket) }
+
+    validates :quantity, numericality: { greater_than_or_equal_to: 0 }
+
+    def to_s
+      persisted? ? "#{quantity}x #{event_ticket}": model_name.human
+    end
+
+  end
+end

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

@@ -9,10 +9,10 @@
   - if f.object.new_record?
     -# User
     - klass = (f.object.owner || current_user).class
-    - ajax_url = (@select2_users_ajax_path || effective_resources.users_admin_select2_ajax_index_path) unless Rails.env.test?
+    - ajax_url = (effective_resources.users_admin_select2_ajax_index_path unless Rails.env.test?)
 
     = f.hidden_field :owner_type, value: klass.name
-    = f.select :owner_id, klass.all, ajax_url: ajax_url, label: 'User'
+    = f.select :owner_id, klass.all, ajax_url: ajax_url, label: 'Registration User'
   - else
     = f.static_field :owner
 
@@ -20,7 +20,20 @@
 
   #effective-events-event-registrant-ajax
     - if f.object.event.present?
-      = render 'effective/event_registrants/fields', f: f, event: event_registrant.event, namespace: :admin
+      .card
+        .card-body
+          - if f.object.purchased?
+            = f.static_field :event_ticket, label: 'Purchased ticket'
+
+          = f.select :event_ticket_id, effective_events_event_tickets_collection(f.object.event, namespace), required: true
+
+          - if f.object.event.allow_blank_registrants? && (f.object.new_record? || f.object.blank_registrant?)
+            = f.check_box :blank_registrant, label: "I will return and add this ticket's information later"
+          - else
+            = f.hidden_field :blank_registrant, value: false
+
+          = f.show_if(:blank_registrant, false) do
+            = render('effective/event_registrants/fields', f: f)
 
   = f.check_box :archived, label: "Archive this registrant. It will be displayed as archived on the owner's event registration"
 

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

@@ -11,7 +11,7 @@
         = f.show_if(:category, 'Regular') do
           .alert.alert-info.mb-4
             %strong Regular Ticket:
-            Anyone will be able to purchase this ticket. They will be asked for a first and last name. Will not display the dropdown list of all members. Only the regular price applies.
+            Anyone will be able to purchase this ticket. Only the regular price applies.
 
         = f.show_if(:category, 'Member Only') do
           .alert.alert-info.mb-4

data/app/views/effective/event_registrants/_fields.html.haml

@@ -1,33 +1,52 @@
-.card.mb-4
-  .card-body
-    - if f.object.purchased?
-      = f.static_field :event_ticket, label: 'Purchased ticket'
-    - else
-      = f.select :event_ticket_id, effective_events_event_tickets_collection(event, namespace), label: 'Ticket'
-
-    - if f.object.purchased? && namespace == :admin
-      = f.select :event_ticket_id, effective_events_event_tickets_collection(event, namespace), label: 'Change Ticket', hint: 'Admin only. Change the purchased ticket. This will not create charges, alter the original order, or consider ticket capacity.'
-
-    - event.event_tickets.each do |ticket|
-      - next if ticket.member_only? && !current_user&.is?(:member)
-
-      = f.show_if(:event_ticket_id, ticket.id) do
-        - if event.allow_blank_registrants? && (f.object.new_record? || f.object.blank_registrant?)
-          = f.check_box :blank_registrant, label: "I will return and add this ticket's information later"
+.event-registrant-user-fields
+  - user_klass = (f.object.user || current_user).class
+  - ajax_url = (effective_events.users_event_registrants_select2_ajax_index_path unless Rails.env.test?)
+  - disabled = (f.object.user.present? && f.object.user.persisted? && f.object.user.errors.blank?)
+  - event_ticket = f.object.event_ticket
+
+  = f.hidden_field :user_type, value: user_klass.name
+
+  = f.select :user_id, user_klass.all, ajax_url: ajax_url, label: "Quick add", placeholder: "Search by name, email, or company",
+    hint: "Can't find someone? Add their details below.", input_js: { minimumInputLength: 1 }, 'data-event-registrant-user-search': true
+
+  .row
+    .col-md= f.text_field :first_name, input_html: { disabled: disabled }
+    .col-md= f.text_field :last_name, input_html: { disabled: disabled }
+
+  .row
+    .col-md= f.email_field :email, input_html: { disabled: disabled }
+    .col-md
+      = f.hidden_field :organization_type
+      = f.hidden_field :organization_id
+
+      - if EffectiveEvents.organization_enabled? == false
+        = f.text_field :company, input_html: { disabled: disabled }
+      
+      - if EffectiveEvents.organization_enabled?
+        = f.hidden_field :organization_type, value: EffectiveMemberships.Organization.name
+
+        - organizations = EffectiveMemberships.Organization.sorted.all
+
+        - if event_ticket&.member_only?
+          - organization_id = (f.object.event_registration&.owner || current_user).try(:organizations).try(:first).try(:id)
+
+          = f.select :organization_id, organizations, label: organization_label, placeholder: 'Search by name', input_html: { disabled: disabled },
+            input_js: { minimumInputLength: 1 },
+            hint: "You can only add new members to your own #{organization_label.downcase}",
+            value: (organization_id if organization_id && f.object.organization_id.blank?)
         - else
-          = f.hidden_field :blank_registrant, value: false
+          - # This creates a select field organization_id and a text field company
+          = f.select_or_text :organization_id, :company, organizations, name: organization_label.downcase, input_html: { disabled: disabled },
+            text: { label: "#{organization_label} name", placeholder: "New #{organization_label.downcase} name" },
+            select: { label: organization_label, placeholder: 'Search by name', input_js: { minimumInputLength: 1 } }
 
-        = f.show_if(:blank_registrant, false, nested: true) do
-          %hr
+  - if event_ticket.present?
+    - if event_ticket.question1.present?
+      = f.text_field :response1, label: event_ticket.question1
 
-          - if ticket.regular?
-            = render('effective/event_registrants/fields_regular', f: f)
-          - elsif ticket.member_only?
-            = render('effective/event_registrants/fields_member_only', f: f)
-          - elsif ticket.member_or_non_member?
-            = render('effective/event_registrants/fields_member_or_non_member', f: f)
-          - else
-            - raise("Unexpected ticket category: #{ticket.category || 'nil'}")
+    - if event_ticket.question2.present?
+      = f.text_field :response2, label: event_ticket.question2
 
-          = render('effective/event_registrants/fields_questions', f: f, ticket: ticket)
+    - if event_ticket.question3.present?
+      = f.text_field :response3, label: event_ticket.question3
 

data/app/views/effective/event_registrations/_details.html.haml

@@ -0,0 +1 @@
+-# Intentionally blank

data/app/views/effective/event_registrations/_fields_event_registrants.html.haml

@@ -0,0 +1,26 @@
+- # Displayed on the details step
+- event = form.object.event
+
+- form.object.event_registrants.each_with_index do |event_registrant, index|
+  = card("Ticket ##{index+1}") do
+    - event_ticket = event_registrant.event_ticket
+
+    %p
+      = event_ticket
+      = ' - '
+
+      - if event_ticket.member_or_non_member? && event_registrant.first_name.blank? && !event.early_bird?
+        = effective_events_ticket_price(event, event_ticket)
+      - else
+        = price_to_currency(event_registrant.price)
+
+      = event_registrant.details
+
+    = form.fields_for :event_registrants, event_registrant do |fr|
+      - if event.allow_blank_registrants? && (fr.object.user.blank? || fr.object.blank_registrant?)
+        = fr.check_box :blank_registrant, label: "I will return and add this ticket's information later"
+      - else
+        = fr.hidden_field :blank_registrant, value: false
+
+      = fr.show_if(:blank_registrant, false) do
+        = render('effective/event_registrants/fields', f: fr)

data/app/views/effective/event_registrations/_fields_event_ticket_selections.html.haml

@@ -0,0 +1,85 @@
+-# Displayed on the tickets step
+- event = form.object.event
+- tickets = event.event_tickets.reject(&:archived?)
+- waitlist = tickets.any? { |ticket| ticket.waitlist? }
+
+- all_member_only_tickets = tickets.all? { |ticket| ticket.member_only? }
+- any_member_only_tickets = tickets.any? { |ticket| ticket.member_only? }
+- is_member = current_user.try(:is?, :member) 
+
+- if event.early_bird?
+  .alert.alert-warning.mb-3
+    Early Bird rates end on
+    = event.early_bird_end_at.strftime("%A, %B %d, %Y at %l:%M%P.")
+
+%table.table.table-sm.table-striped
+  %thead
+    %tr
+      %th Ticket
+      %th Price
+      %th Quantity
+
+  %tbody
+    - tickets.each do |ticket|
+      %tr
+        %td
+          = ticket.to_s
+          - if ticket.capacity.present? && ticket.display_capacity?
+            %br
+            %small
+              #{event.capacity_available(event_ticket: ticket, event_registration: form.object)} remaining
+              - if ticket.waitlist?
+                before waitlist
+        %td
+          %ul.list-unstyled.mb-0
+            - # Early Bird
+            - if event.early_bird? && ticket.early_bird_price.to_i > 0 && [ticket.member_price, ticket.regular_price].exclude?(ticket.early_bird_price)
+              %li
+                - if ticket.regular_price.to_i > 0
+                  %div
+                    %s.text-muted
+                      = price_to_currency(ticket.regular_price)
+
+                - if ticket.member_price.to_i > 0
+                  %div
+                    %s.text-muted
+                      = price_to_currency(ticket.member_price)
+                    .badge.badge-secondary.mr-2 Members
+
+                %div
+                  = price_to_currency(ticket.early_bird_price)
+                  .badge.badge-warning Early Bird
+            - else
+              - if ticket.regular_price.present?
+                %li
+                  = price_to_currency(ticket.regular_price)
+
+              - if ticket.member_price.present?
+                %li
+                  = price_to_currency(ticket.member_price)
+                  .badge.badge-secondary Members
+
+        %td
+          - event_ticket_selection = form.object.event_ticket_selection(event_ticket: ticket)
+
+          = form.fields_for :event_ticket_selections, event_ticket_selection do |f|
+            = f.hidden_field :event_ticket_id
+            = f.hidden_field :quantity, value: 0
+
+            - capacity = event.capacity_selectable(event_ticket: ticket, event_registration: form.object)
+            - disabled = (ticket.member_only? && !is_member)
+
+            - if form.object.selected_expired? && !f.object.errors.present?
+              - f.object.assign_attributes(quantity: 0)
+
+            = f.select :quantity, (0..capacity), label: false, disabled: disabled, 
+              include_blank: false, input_js: { minimumResultsForSearch: 'Infinity' }
+
+- if waitlist
+  %p If the ticket capacity has been reached you will be added to the waitlist.
+
+- unless is_member
+  - if all_member_only_tickets
+    .alert.alert-info.mb-4 You must be a member to purchase tickets.
+  - elsif any_member_only_tickets
+    .alert.alert-info.mb-4 You must be a member to purchase some of these tickets.