effective_events 0.1.0

data/app/models/concerns/effective_events_event_registration.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+# EffectiveEventsEventRegistration
+#
+# Mark your owner model with effective_events_event_registration to get all the includes
+
+module EffectiveEventsEventRegistration
+  extend ActiveSupport::Concern
+
+  module Base
+    def effective_events_event_registration
+      include ::EffectiveEventsEventRegistration
+    end
+  end
+
+  module ClassMethods
+    def effective_events_event_registration?; true; end
+
+    def all_wizard_steps
+      const_get(:WIZARD_STEPS).keys
+    end
+
+    def required_wizard_steps
+      [:start, :summary, :billing, :checkout, :submitted]
+    end
+  end
+
+  included do
+    acts_as_purchasable_parent
+    acts_as_tokened
+
+    acts_as_statused(
+      :draft,      # Just Started
+      :submitted   # All done
+    )
+
+    acts_as_wizard(
+      start: 'Start',
+      registrants: 'Registrants',
+      summary: 'Review',
+      billing: 'Billing Address',
+      checkout: 'Checkout',
+      submitted: 'Submitted'
+    )
+
+    log_changes(except: :wizard_steps) if respond_to?(:log_changes)
+
+    # Application Namespace
+    belongs_to :owner, polymorphic: true
+    accepts_nested_attributes_for :owner
+
+    # Effective Namespace
+    belongs_to :event
+
+    has_many :event_registrants, -> { order(:id) }, inverse_of: :event_registration, dependent: :destroy
+    accepts_nested_attributes_for :event_registrants, reject_if: :all_blank, allow_destroy: true
+
+    has_many :orders, -> { order(:id) }, as: :parent, class_name: 'Effective::Order', dependent: :nullify
+    accepts_nested_attributes_for :orders
+
+    effective_resource do
+      # Acts as Statused
+      status                 :string, permitted: false
+      status_steps           :text, permitted: false
+
+      # Dates
+      submitted_at           :datetime
+
+      # Acts as Wizard
+      wizard_steps           :text, permitted: false
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:owner, :event, :event_registrants) }
+    scope :sorted, -> { order(:id) }
+
+    scope :in_progress, -> { where.not(status: [:submitted]) }
+    scope :done, -> { where(status: [:submitted]) }
+
+    scope :for, -> (user) {
+      owner = (user.respond_to?(:effective_memberships_owners) ? user.effective_memberships_owners : user)
+      where(owner: owner)
+    }
+
+    # All Steps validations
+    validates :owner, presence: true
+    validates :event, presence: true
+
+    # Registrants Step
+    validate(if: -> { current_step == :registrants }) do
+      self.errors.add(:event_registrants, "can't be blank") unless present_event_registrants.present?
+    end
+
+    # Billing Step
+    validate(if: -> { current_step == :billing && owner.present? }) do
+      self.errors.add(:base, "must have a billing address") unless owner.billing_address.present?
+      self.errors.add(:base, "must have an email") unless owner.email.present?
+    end
+
+    after_purchase do |_|
+      raise('expected submit_order to be purchased') unless submit_order&.purchased?
+      submit_purchased!
+      after_submit_purchased!
+    end
+  end
+
+  # Instance Methods
+  def to_s
+    persisted? ? "Registration ##{id}" : 'Event Registration'
+  end
+
+  def in_progress?
+    draft?
+  end
+
+  def done?
+    submitted?
+  end
+
+  def can_visit_step?(step)
+    can_revisit_completed_steps(step)
+  end
+
+  # Find or build
+  def event_registrant(first_name:, last_name:, email:)
+    registrant = event_registrants.find { |er| er.first_name == first_name && er.last_name == last_name && er.email == email }
+    registrant || event_registrants.build(event: event, 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(first_name: owner.first_name, last_name: owner.last_name, email: owner.email)
+    end
+
+    event_registrants
+  end
+
+  # All Fees and Orders
+  def submit_fees
+    event_registrants
+  end
+
+  def submit_order
+    orders.first
+  end
+
+  def find_or_build_submit_order
+    order = submit_order || orders.build(user: owner)
+    fees = submit_fees()
+
+    # Adds fees, but does not overwrite any existing price.
+    fees.each do |fee|
+      order.add(fee) unless order.purchasables.include?(fee)
+    end
+
+    order.purchasables.each do |purchasable|
+      order.remove(purchasable) unless fees.include?(purchasable)
+    end
+
+    # From Billing Step
+    order.billing_address = owner.billing_address if owner.billing_address.present?
+
+    # Important to add/remove anything
+    order.save
+
+    order
+  end
+
+  # Should be indempotent.
+  def build_submit_fees_and_order
+    return false if was_submitted?
+
+    fees = submit_fees()
+    raise('already has purchased submit fees') if fees.any?(&:purchased?)
+
+    order = find_or_build_submit_order()
+    raise('already has purchased submit order') if order.purchased?
+
+    true
+  end
+
+  # If they go back and change registrants. Update the order right away.
+  def registrants!
+    save!
+    build_submit_fees_and_order if submit_order.present?
+    true
+  end
+
+  # Owner clicks on the Billing step. Next step is Checkout
+  def billing!
+    ready!
+  end
+
+  # Ready to check out
+  def ready!
+    build_submit_fees_and_order
+    save!
+  end
+
+  # Called automatically via after_purchase hook above
+  def submit_purchased!
+    return false if was_submitted?
+
+    wizard_steps[:checkout] = Time.zone.now
+    submit!
+  end
+
+  # A hook to extend
+  def after_submit_purchased!
+  end
+
+  # Draft -> Submitted requirements
+  def submit!
+    raise('already submitted') if was_submitted?
+    raise('expected a purchased order') unless submit_order&.purchased?
+
+    wizard_steps[:checkout] ||= Time.zone.now
+    wizard_steps[:submitted] = Time.zone.now
+    submitted!
+  end
+
+  private
+
+  def present_event_registrants
+    event_registrants.reject(&:marked_for_destruction?)
+  end
+
+end

data/app/models/effective/event.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Effective
+  class Event < ActiveRecord::Base
+    has_many :event_registrants, -> { order(:event_ticket_id, :created_at) }, inverse_of: :event
+    accepts_nested_attributes_for :event_registrants, allow_destroy: true
+
+    has_many :event_tickets, -> { order(:id) }, inverse_of: :event
+    accepts_nested_attributes_for :event_tickets, allow_destroy: true
+
+    # rich_text_body - Used by the select step
+    has_many_rich_texts
+
+    # rich_text_body
+    # rich_text_excerpt
+
+    # rich_text_all_steps_content
+    # rich_text_start_content
+    # rich_text_select_content
+    # rich_text_select_content
+
+    acts_as_slugged
+    log_changes if respond_to?(:log_changes)
+    acts_as_role_restricted if respond_to?(:acts_as_role_restricted)
+
+    self.table_name = EffectiveEvents.events_table_name.to_s
+
+    effective_resource do
+      title                  :string
+
+      slug                   :string
+      draft                  :boolean
+
+      start_at               :datetime
+      end_at                 :datetime
+
+      registration_start_at  :datetime
+      registration_end_at    :datetime
+
+      early_bird_end_at      :datetime  # Optional
+
+      # Access
+      roles_mask             :integer
+      authenticate_user      :boolean
+
+      timestamps
+    end
+
+    scope :sorted, -> { order(:end_at) }
+    scope :deep, -> { includes(:event_registrants, :event_tickets) }
+
+    scope :drafts, -> { where(draft: true) }
+    scope :published, -> { where(draft: false) }
+
+    scope :upcoming, -> { where(arel_table[:end_at].gt(Time.zone.now)) }
+    scope :past, -> { where(arel_table[:end_at].lteq(Time.zone.now)) }
+
+    scope :closed, -> { where(arel_table[:registration_end_at].lt(Time.zone.now)) }
+    scope :not_closed, -> { where(arel_table[:registration_end_at].gteq(Time.zone.now)) }
+
+    scope :with_tickets, -> { where(id: Effective::EventTicket.select('event_id')) }
+
+    # Doesnt consider sold out yet
+    scope :registerable, -> { published.not_closed.with_tickets }
+
+    scope :paginate, -> (page: nil, per_page: nil) {
+      page = (page || 1).to_i
+      offset = [(page - 1), 0].max * (per_page || EffectiveEvents.per_page)
+
+      limit(per_page).offset(offset)
+    }
+
+    scope :events, -> (user: nil, unpublished: false) {
+      scope = all.deep.sorted
+
+      if defined?(EffectiveRoles) && EffectivePosts.use_effective_roles
+        scope = scope.for_role(user&.roles)
+      end
+
+      if user.blank?
+        scope = scope.where(authenticate_user: false)
+      end
+
+      unless unpublished
+        scope = scope.published
+      end
+
+      scope
+    }
+
+    validates :title, presence: true, length: { maximum: 255 }
+
+    validates :start_at, presence: true
+    validates :end_at, presence: true
+    validates :registration_start_at, presence: true
+    validates :registration_end_at, presence: true
+
+    validate(if: -> { start_at && end_at }) do
+      self.errors.add(:end_at, 'must be after start date') unless start_at < end_at
+    end
+
+    validate(if: -> { start_at && registration_start_at }) do
+      self.errors.add(:registration_start_at, 'must be before start date') unless registration_start_at < start_at
+    end
+
+    validate(if: -> { registration_start_at && registration_end_at }) do
+      self.errors.add(:registration_end_at, 'must be after start registration date') unless registration_start_at < registration_end_at
+    end
+
+    validate(if: -> { start_at && early_bird_end_at }) do
+      self.errors.add(:early_bird_end_at, 'must be before start date') unless early_bird_end_at < start_at
+    end
+
+    def to_s
+      title.presence || 'New Event'
+    end
+
+    def body
+      rich_text_body
+    end
+
+    def excerpt
+      rich_text_excerpt
+    end
+
+    def registerable?
+      return false if draft?
+      return false if closed?
+      return false if sold_out?
+      return false if event_tickets.blank?
+
+      true
+    end
+
+    def closed?
+      return false if registration_end_at.blank?
+      registration_end_at < Time.zone.now
+    end
+
+    def sold_out?
+      false
+    end
+
+    def early_bird?
+      return false if early_bird_end_at.blank?
+      early_bird_end_at < Time.zone.now
+    end
+
+    def early_bird_past?
+      return false if early_bird_end_at.blank?
+      early_bird_end_at >= Time.zone.now
+    end
+
+    def early_bird_status
+      if early_bird?
+        'Early Bird Pricing'
+      elsif early_bird_past?
+        'Expired'
+      else
+        'None'
+      end
+    end
+
+    # Returns a duplicated event object, or throws an exception
+    def duplicate
+      Event.new(attributes.except('id', 'updated_at', 'created_at')).tap do |event|
+        event.title = event.title + ' (Copy)'
+        event.slug = event.slug + '-copy'
+        event.draft = true
+
+        event.body = body
+        event.excerpt = excerpt
+      end
+    end
+
+    def duplicate!
+      duplicate.tap { |event| event.save! }
+    end
+
+  end
+end

data/app/models/effective/event_registrant.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Effective
+  class EventRegistrant < ActiveRecord::Base
+    acts_as_purchasable
+    log_changes(to: :event) if respond_to?(:log_changes)
+
+    belongs_to :event, counter_cache: true
+
+    # Basically a category containing all the pricing and unique info about htis registrant
+    belongs_to :event_ticket
+
+    # Every event registrant is charged to a owner
+    belongs_to :owner, polymorphic: true
+
+    # This fee when checked out through the event registration
+    belongs_to :event_registration, polymorphic: true, optional: true
+
+    effective_resource do
+      first_name    :string
+      last_name     :string
+      email         :string
+
+      company       :string
+      number        :string
+      notes         :text
+
+      # Acts as Purchasable
+      price             :integer
+      qb_item_name      :string
+      tax_exempt        :boolean
+
+      timestamps
+    end
+
+    scope :sorted, -> { order(:last_name) }
+    scope :deep, -> { all }
+
+    validates :first_name, presence: true
+    validates :last_name, presence: true
+    validates :email, presence: true, email: true
+
+    before_validation(if: -> { event_registration.present? }) do
+      self.event ||= event_registration.event
+      self.owner ||= event_registration.owner
+    end
+
+    before_validation(if: -> { event_ticket.present? }) do
+      self.price ||= event_ticket.price
+    end
+
+    def to_s
+      persisted? ? title : 'registrant'
+    end
+
+    def title
+      "#{event_ticket} - #{last_first_name}"
+    end
+
+    def last_first_name
+      "#{last_name}, #{first_name}"
+    end
+
+    def tax_exempt
+      event_ticket.tax_exempt
+    end
+
+    def qb_item_name
+      event_ticket.qb_item_name
+    end
+
+    # This is the Admin Save and Mark Paid action
+    def mark_paid!
+      raise('expected a blank event registration') if event_registration.present?
+
+      save!
+
+      order = Effective::Order.new(items: self, user: owner)
+      order.purchase!(skip_buyer_validations: true, email: false)
+
+      true
+    end
+
+  end
+end

data/app/models/effective/event_registration.rb

@@ -0,0 +1,7 @@
+module Effective
+  class EventRegistration < ActiveRecord::Base
+    self.table_name = EffectiveEvents.event_registrations_table_name.to_s
+
+    effective_events_event_registration
+  end
+end

data/app/models/effective/event_ticket.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Effective
+  class EventTicket < ActiveRecord::Base
+    belongs_to :event
+
+    has_many :event_registrants
+    has_many :purchased_event_registrants, -> { EventRegistrant.purchased }, class_name: 'Effective::EventRegistrant'
+
+    log_changes(to: :event) if respond_to?(:log_changes)
+
+    has_rich_text :body
+
+    effective_resource do
+      title                 :string
+      capacity              :integer
+
+      # Pricing
+      regular_price         :integer
+      early_bird_price      :integer
+
+      qb_item_name          :string
+      tax_exempt            :boolean
+
+      position              :integer
+
+      timestamps
+    end
+
+    scope :sorted, -> { order(:position) }
+    scope :deep, -> { with_rich_text_body.includes(:purchased_event_registrants) }
+
+    before_validation(if: -> { event.present? }) do
+      self.position ||= (event.event_tickets.map(&:position).compact.max || -1) + 1
+    end
+
+    validates :title, presence: true
+    validates :regular_price, presence: true
+    validates :early_bird_price, presence: true, if: -> { event&.early_bird_end_at.present? }
+
+    def to_s
+      title.presence || 'New Event Ticket'
+    end
+
+    def price
+      event.early_bird? ? early_bird_price : regular_price
+    end
+
+    def capacity_available?
+      return true if capacity.blank?
+      capacity <= purchased_event_registrants.count
+    end
+
+    def purchased_event_registrants_count
+      purchased_event_registrants.count
+    end
+
+  end
+end

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

@@ -0,0 +1,14 @@
+= effective_form_with(model: [:admin, event_registrant], engine: true) do |f|
+  = f.hidden_field :event_id
+
+  - if f.object.new_record?
+    = f.select :owner, { 'Users' => current_user.class.all }, polymorphic: true
+  - else
+    = f.static_field :owner
+
+  = render 'effective/event_registrants/fields', f: f, event: event_registrant.event
+
+  - if f.object.new_record?
+    = f.submit 'Save and Mark Paid'
+  - else
+    = f.submit 'Save'

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

@@ -0,0 +1,7 @@
+= effective_form_with(model: [:admin, event_ticket], engine: true) do |f|
+  = f.hidden_field :event_id
+
+  /= f.number_field :capacity, hint: 'The number of online purchases will be loosely limited to capacity.'
+  = render 'effective/event_tickets/fields', f: f
+
+  = effective_submit(f)

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

@@ -0,0 +1,27 @@
+= tabs do
+  = tab "Event" do
+    = render 'admin/events/form_event', event: event
+
+  - if event.persisted?
+    = tab 'Registrants' do
+      - datatable = Admin::EffectiveEventRegistrantsDatatable.new(event_id: event.id)
+      = render_inline_datatable(datatable)
+
+    = tab 'Content' do
+      = render '/admin/events/form_content', event: event
+
+    = tab 'Tickets' do
+      %p An event must have tickets before registration can begin
+
+      - datatable = Admin::EffectiveEventTicketsDatatable.new(event_id: event.id)
+      = render_inline_datatable(datatable)
+
+    = tab 'Registration' do
+      = render '/admin/events/form_event_registration_content', event: event
+
+    = tab 'Access' do
+      = render '/admin/events/form_access', event: event
+
+    - if event.respond_to?(:log_changes_datatable)
+      = tab "Logs" do
+        = render_inline_datatable(event.log_changes_datatable)

data/app/views/admin/events/_form_access.html.haml

@@ -0,0 +1,10 @@
+= effective_form_with(model: event, url: event.persisted? ? effective_events.admin_event_path(event.id) : effective_events.admin_events_path) do |f|
+  = f.check_box :authenticate_user, label: 'Yes, the user must be be signed in to view this event', hint: 'Sign up is required to register for any event'
+
+  - if EffectiveEvents.use_effective_roles
+    = f.checks :roles, EffectiveRoles.roles_collection(f.object)
+
+  %p.text-hint
+    * leave blank for a regular public event that anyone can view
+
+  = f.submit

data/app/views/admin/events/_form_content.html.haml

@@ -0,0 +1,5 @@
+= effective_form_with(model: [:admin, event], engine: true) do |f|
+  = f.rich_text_area :rich_text_excerpt, hint: 'Will be used for the events excerpt on index pages.'
+  = f.rich_text_area :rich_text_body, hint: 'The main body of your event'
+
+  = f.submit

data/app/views/admin/events/_form_event.html.haml

@@ -0,0 +1,24 @@
+= effective_form_with(model: [:admin, event], engine: true) do |f|
+  = f.text_field :title, label: "Title"
+  = f.check_box :draft, hint: 'Save this event as a draft. It will not be accessible on the website.'
+
+  - if f.object.persisted? || f.object.errors.include?(:slug)
+    - current_url = (effective_events.event_url(f.object) rescue nil)
+    = f.text_field :slug, hint: "The slug controls this event's internet address. Be careful, changing the slug will break links that other websites may have to the old address.<br>#{('This event is currently reachable via ' + link_to(current_url.gsub(f.object.slug, '<strong>' + f.object.slug + '</strong>').html_safe, current_url)) if current_url }".html_safe
+
+  = f.datetime_field :start_at, label: "Event Start"
+  = f.datetime_field :end_at, label: "Event End"
+
+  %h2 Registration Opens
+  %p The online registration and purchase for this event will be available between:
+  = f.datetime_field :registration_start_at, label: "Registration Start"
+  = f.datetime_field :registration_end_at, label: "Registration End"
+
+  = f.datetime_field :early_bird_end_at, label: "Early Bird End",
+    hint: 'Event tickets can be purchased for early bird pricing before this date. Afterwards regular pricing applies.'
+
+  = f.submit do
+    = f.save 'Save'
+    = f.save 'Save and View', class: 'btn btn-secondary'
+    - if f.object.persisted?
+      = f.save 'Duplicate', class: 'btn btn-info'

data/app/views/admin/events/_form_event_registration_content.html.haml

@@ -0,0 +1,19 @@
+%p Each of the following content areas will be displayed on the event registration wizard.
+
+= effective_form_with(model: [:admin, event], engine: true) do |f|
+  = card("All Steps") do
+    = f.rich_text_area "rich_text_all_steps_content", label: false,
+      hint: "displayed on all steps"
+
+  %hr
+
+  - enabled = EffectiveEvents.EventRegistration.all_wizard_steps
+
+  - EffectiveEvents.EventRegistration::WIZARD_STEPS.each do |step, title|
+    - next unless enabled.include?(step)
+
+    = card("#{title}") do
+      = f.rich_text_area "rich_text_#{step}_content", label: false,
+        hint: "displayed on the event registration #{step} wizard step only"
+
+  = f.submit

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

@@ -0,0 +1,19 @@
+.card
+  .card-body
+    %h5.card-title Event Registrant
+
+    - if f.object.purchased?
+      = f.static_field :event_ticket, label: 'Purchased event ticket'
+    - else
+      = f.select :event_ticket_id, effective_events_event_tickets_collection(event)
+
+    .row
+      .col-lg= f.text_field :first_name
+      .col-lg= f.text_field :last_name
+      .col-lg= f.text_field :number
+
+    .row
+      .col-lg= f.email_field :email
+      .col-lg= f.text_field :company
+
+    = f.text_area :notes, label: 'Dietary restrictions or other notes'