artfully_ose 1.3.0.pre3 → 1.3.0.pre4

data/app/models/imports/events_import.rb

@@ -162,7 +162,7 @@ class EventsImport < Import
     
     raise Import::RuntimeError, 'No section found for ticket' unless section
     
-    ticket = Ticket.build_one(show, section,1, true)
+    ticket = Ticket.build_one(show, section, true)
     ticket.ticket_type = ticket_type
     Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Ticket built [#{ticket.inspect}]")
     ticket.sell_to person

data/app/models/job/show_creator.rb

@@ -1,26 +1,19 @@
 class ShowCreator < Struct.new(:datetimes, :show_params, :chart_params, :event, :organization, :publish)
 
-  #
-  # If datetime.length < 3, the shows will create right away. Otherwise, they'll be queued
-  #
   def self.enqueue(datetimes, show_params, chart_params, event, organization, publish = false)
     datetimes ||= []
     creator = ShowCreator.new(datetimes, show_params, chart_params, event, organization, publish)
-    if datetimes.length < 3
-      creator.perform
-    else
-      Delayed::Job.enqueue(creator)
-    end
+    Delayed::Job.enqueue(creator)
   end
 
   def perform
     ActiveRecord::Base.transaction do
       datetimes.each do |datetime_string|     
-        @show = self.event.next_show 
+        @show = self.event.build_next_show 
         
         #clear the sections and replace them with whatever they entered
         @show.chart.sections = []
-        @show.chart.update_attributes_from_params(chart_params)
+        @show.chart.update_attributes_from_params(chart_params, self.event.default_chart)
         @show.update_attributes(show_params)
         @show.organization = organization
         @show.chart_id = @show.chart.id

data/app/models/kit.rb

@@ -83,7 +83,17 @@ class Kit < ActiveRecord::Base
   end
 
   def self.subklasses
-    @subklasses ||= [ TicketingKit, RegularDonationKit, SponsoredDonationKit, ResellerKit, MailchimpKit, MembershipKit, PassesKit, ScannableTicketsKit, RelationshipsKit ].freeze
+    @subklasses ||= [ TicketingKit, 
+                      RegularDonationKit, 
+                      SponsoredDonationKit, 
+                      ResellerKit, 
+                      MailchimpKit, 
+                      MembershipKit, 
+                      PassesKit, 
+                      ScannableTicketsKit, 
+                      RelationshipsKit, 
+                      CampaignsKit,
+                      AssignedSeatingKit ].freeze
   end
 
   def self.pad_with_new_kits(kits = [])

data/app/models/kits/assigned_seating_kit.rb

@@ -0,0 +1,23 @@
+class AssignedSeatingKit < Kit
+
+  acts_as_kit :admin_only => true do
+    self.configurable = false
+
+    state_machine do
+      state :cancelled, :enter => :kit_cancelled
+      event(:submit_for_approval) { transitions :from => :fresh, :to => :pending }
+    end
+
+    when_active do |organization|
+      organization.can :access, :assigned_seating
+    end
+  end
+
+  def friendly_name
+    "Assigned Seating"
+  end  
+
+  def pitch
+    "Assigned Seating"
+  end
+end

data/app/models/member_walkup.rb

@@ -95,7 +95,7 @@ class MemberWalkup
   def ticket
     unless @ticket
       return nil unless valid?
-      @ticket = ticket_type.available_tickets(1, member).first
+      @ticket = ticket_type.available_tickets(1, member)[0].first
     end
     @ticket
   end

data/app/models/order_handler.rb

@@ -17,14 +17,20 @@ class OrderHandler
     self.handle_discount_or_pass_code(params)
   end
 
+  def add_tickets(tickets, ticket_type)
+    #check availability, obv
+    Ticket.lock(tickets, ticket_type, self.cart)
+  end
+
   def handle_tickets(params)
     if params[:ticket_type_id]
       ticket_ids = []
       over_limit = []
 
       ticket_type = TicketType.find(params[:ticket_type_id])
+      seat = params[:seat_id].present? ? Seat.find(params[:seat_id]) : nil
       Rails.logger.debug("QUANTITY #{params[:quantity].to_i}")
-      tickets = ticket_type.available_tickets(params[:quantity].to_i, member)
+      tickets, self.error = ticket_type.available_tickets(params[:quantity].to_i, member, seat, self.cart)
       ids = tickets.collect(&:id)
       Rails.logger.debug("TICKET IDS: #{ids}")
       Ticket.lock(tickets, ticket_type, self.cart)
@@ -35,6 +41,7 @@ class OrderHandler
         #TODO: return and display a sensible error message
       end
 
+
       params = params.merge(:tickets => ticket_ids) if ticket_ids.any?
     end
     params
@@ -124,16 +131,25 @@ class OrderHandler
     def handle_discount(params)
       begin
         discount = nil
-        self.cart.tickets.each do |ticket|
-          discount = Discount.find_by_code_and_event_id(params[:discount_or_pass_code].upcase, ticket.show.event.id)
-          unless discount.nil?
-            discount.apply_discount_to_cart(self.cart)
-            break
+
+        #
+        # If we have an event_id (discount was entered from specific event storefront)
+        # then find the discount with that. Otherwise, interrogate the cart to get
+        # events fro the tickets
+        #
+        if params[:event_id].present?
+          discount = Discount.find_by_code_and_event_id(params[:discount_or_pass_code].upcase, params[:event_id])
+        else
+          self.cart.tickets.each do |ticket|
+            discount = Discount.find_by_code_and_event_id(params[:discount_or_pass_code].upcase, ticket.show.event.id)
+            break if discount
           end
         end
 
         if discount.nil?
           self.error = "We could not find your discount. Please try again."
+        else
+          discount.apply_discount_to_cart(self.cart)
         end
       rescue RuntimeError => e
         self.error = e.message

data/app/models/organization.rb

@@ -7,6 +7,7 @@ class Organization < ActiveRecord::Base
   attr_accessible :name, :time_zone, :ein, :legal_organization_name, :email, :receive_daily_sales_report, :country, :state, :zip, :phone_number, :website, :discipline, :cached_slug, :fiscal_month, :fiscal_day, :budget_restrictions_attributes
 
   has_many :events
+  has_many :venues
   has_many :charts
   has_many :shows
   has_many :tickets
@@ -113,13 +114,11 @@ class Organization < ActiveRecord::Base
     users.order('user_memberships.id asc').first
   end
 
-  #
-  # A shorthand for "first org admin" basically meaning "Just get me someone at the org"
-  #
   def owner
-    @owner ||= UserMembership.includes(:user).where(:organization_id => self.id).where(:organization_administrator => true).first.try(:user)
+    # @owner ||= UserMembership.includes(:user).where(:organization_id => self.id).where(:organization_administrator => true).first.try(:user)
+    @owner ||= user_memberships.select{|um| um.organization_administrator == true}.first.try(:user)
   end
-
+  
   def daily_sales_report_recipients
     @recipients ||= UserMembership.includes(:user).where(:organization_id => self.id).where(:receive_daily_sales_report => true).collect(&:user)
   end

data/app/models/person.rb

@@ -41,6 +41,7 @@ class Person < ActiveRecord::Base
   has_one     :member
   has_many    :memberships, :through => :member
   has_many    :passes
+  has_many    :holds, :class_name => "Seat", :foreign_key => :held_for_id
 
   has_many    :relationships, :foreign_key => :person_id, :class_name => 'Relationship', :dependent => :destroy
 
@@ -151,7 +152,7 @@ class Person < ActiveRecord::Base
   # Tickets are a special case
   #
   def self.mergables
-    [:actions, :phones, :notes, :orders, :soft_credits, :scheduled_pledge_payments, :passes, :subscribed_lists]
+    [:actions, :phones, :notes, :orders, :soft_credits, :scheduled_pledge_payments, :passes, :subscribed_lists, :holds]
   end
 
   def self.loser_attributes_update_if_winner_not_present
@@ -807,6 +808,7 @@ class Person < ActiveRecord::Base
 
   def subscribe_to_default_mailchimp_list!
     return unless mailchimp_kit
+    return if subscribed_lists.where(:list_id => mailchimp_kit.default_list_id).exists?
     subscribed_lists.create(:list_id => mailchimp_kit.default_list_id, :single_optin => true)
   end
 

data/app/models/sale.rb

@@ -48,7 +48,7 @@ class Sale
       amount_requested = @quantities[ticket_type_id].to_i
       if amount_requested > 0
         ticket_type = TicketType.find(ticket_type_id)
-        tickets_available_in_ticket_type = ticket_type.available_tickets(amount_requested)
+        tickets_available_in_ticket_type, error = ticket_type.available_tickets(amount_requested)
         if tickets_available_in_ticket_type.length != amount_requested
           errors.add(:base, "There aren't enough tickets available for that ticket type")
         else

data/app/models/seat.rb

@@ -0,0 +1,96 @@
+class Seat < ActiveRecord::Base
+  # Even though we will eventually support multiple physical sections,
+  # Seat does not FK to Section. The reasons are:
+  #
+  # 1) section.rb has a ton of legacy junk in there.
+  # 2) section.rb is closely tied to ticket types, prices, etc...
+  #
+  # When we support multiple physical sections, we'll probably have Seat
+  # FK to a new object, like assigned_section or physical_section.
+
+  belongs_to  :chart
+  belongs_to  :held_for, :class_name => "Person", :foreign_key => :held_for_id
+  has_many    :ticket_types_seats
+  has_many    :ticket_types, :through => :ticket_types_seats, :dependent => :destroy
+  has_one     :ticket
+
+  attr_accessible :row_index,   # The 0-based row index of the seat irrespective of actual names
+                  :col_index,   # The 0-based column index of the seat irrespective of actual names
+                  :row_label,   # The actual name of the row "B" or "AAA"
+                  :col_label,   # The seat number. "17"
+                  :label,       # The physical label on the physical seat "4B", "B4", or "17".
+                  :available    # Is the seat available for purchase. Roughly analogous to "on_sale"
+
+  #
+  # "available" means that the seat isn't killed or held
+  # "available_for_purchase" means the underlying ticket can be purchased
+  #
+  def available_for_purchase
+    self.available && self.ticket && self.ticket.on_sale? && !self.ticket.locked?
+  end
+
+  def on_hold?
+    self.house_hold?        ||
+    self.development_hold?  ||
+    self.tech_hold?         ||
+    self.contractual_hold?  ||
+    self.person_hold?       ||
+    self.press_hold
+  end
+
+  def dup!
+    Seat.new(self.attributes.reject { |key, value| ["chart_id", "id"].include? key }, :without_protection => true)
+  end
+
+  def update_ticket
+    if self.ticket.present?
+      if self.on_hold?
+        self.ticket.off_sale! if ticket.on_sale?
+      else
+        self.ticket.on_sale! if self.ticket.off_sale?
+      end
+    end
+  end
+
+  def applies_to_pass?(pass)
+    self.ticket_types.each do |ticket_type|
+      return true if ticket_type.applies_to_pass? pass 
+    end
+    false
+  end
+
+  def hold_type
+    return nil unless self.on_hold?
+    return "House" if self.house_hold?
+    return "Development" if self.development_hold?
+    return "Tech" if self.tech_hold?         
+    return "Contractural" if self.contractual_hold?  
+    return "Person" if self.person_hold?       
+    return "Press" if self.press_hold    
+  end
+
+  def member_ticket_for?(membership_types)
+    return false if membership_types.empty?
+    self.ticket_types.select{|tt| membership_types.collect(&:id).include? tt.membership_type_id }.present?
+  end
+
+  #
+  # A human-readable qualifier to be displayed during ticket type selection
+  #
+  def qualifier
+    return "Wheelchair removable seat" if self.wheelchair
+    return "Wheelchair companion seat" if self.wheelchair_companion
+    return "Designated aisle seat"     if self.aisle
+  end
+
+  #
+  # Don't make this a callback! Charts and shows and everything else have a process
+  # about creating tickets when a producer creates a show. This method is for seats created *after* a show
+  # has been created and put on sale
+  #
+  def create_ticket
+    if self.chart.show.present? && self.ticket.nil?
+      Ticket.build_one(self.chart.show, self.chart.sections.first, !self.on_hold?, self).save
+    end
+  end
+end

data/app/models/section.rb

@@ -1,7 +1,5 @@
 class Section < ActiveRecord::Base
-  include Ticket::Foundry
   attr_accessor :skip_create_first_ticket_type
-  foundry :with => lambda { { :section_id => id, :count => capacity } }
 
   attr_accessible :name, :capacity, :price, :chart_id, :description, :ticket_types_attributes, :members
   delegate :show, :to => :chart
@@ -74,7 +72,7 @@ class Section < ActiveRecord::Base
   end
 
   def dup!    
-    attrs = self.attributes.reject { |key, value| key == 'id' }
+    attrs = self.attributes.reject { |key, value| ["chart_id", "id"].include? key }
     self.class.new(attrs).tap do |copy|
       copy.ticket_types = self.ticket_types.collect { |ticket_type| ticket_type.dup! }
     end

data/app/models/show.rb

@@ -1,5 +1,4 @@
 class Show < ActiveRecord::Base
-  include Ticket::Foundry
   include Ticket::Reporting
   include ActiveRecord::Transitions
   include Ext::Resellable::Show
@@ -41,8 +40,6 @@ class Show < ActiveRecord::Base
   scope :played,    lambda { where("shows.datetime < ?", Time.now) }
   scope :unplayed,  lambda { where("shows.datetime > ?", Time.now) }
 
-  foundry :using => :chart, :with => lambda {{:show_id => self.id, :organization_id => organization_id}}
-
   delegate :free?, :to => :event
 
   ANY_SHOW_ID = "-1"
@@ -51,7 +48,7 @@ class Show < ActiveRecord::Base
 
     #pending and built are deprecated, left in only because we have shows in production which are built
     state :pending
-    state :built, :exit => :create_and_on_sale_tickets
+    state :built, :exit => :create_tickets
     state :published
     state :unpublished
 
@@ -115,13 +112,19 @@ class Show < ActiveRecord::Base
     self.cached_stats
   end
 
+  #
+  # uses cached_stats instead of going to the DB
+  #
+  def sold_out?
+    self.on_sale < 1
+  end
+
   def parsed_local_datetime
     @parsed_local_datetime = (DateTime.parse(self.local_datetime.to_s) rescue self.datetime_local_to_event)
   end
 
-  def create_and_on_sale_tickets
-    create_tickets
-    bulk_on_sale(:all)
+  def create_tickets
+    self.chart.create_tickets
   end
 
   def unscoped_event
@@ -206,16 +209,6 @@ class Show < ActiveRecord::Base
                   :chart => chart_for("storefront", options[:organization_id]).as_json(options))
   end
 
-  def bulk_on_sale(ids)
-    targets = (ids == :all) ? tickets : tickets.where(:id => ids)
-    Ticket.put_on_sale(targets)
-  end
-
-  def bulk_off_sale(ids)
-    targets = (ids == :all) ? tickets : tickets.where(:id => ids)
-    Ticket.take_off_sale(targets)
-  end
-
   def bulk_delete(ids)
     tickets.where(:id => ids).collect{ |ticket| ticket.id if ticket.destroy }#.compact
   end

data/app/models/ticket.rb

@@ -21,6 +21,7 @@ class Ticket < ActiveRecord::Base
   belongs_to :pass
   belongs_to :discount
   belongs_to :action, :foreign_key => "validated_action_id", :class_name => "GoAction"
+  belongs_to :seat
 
   #
   # This refs the ticket_type that the ticket was sold under, 
@@ -55,15 +56,34 @@ class Ticket < ActiveRecord::Base
   scope :sold_or_comped, where(:state => [:sold, :comped])
 
   state_machine :auto_scopes => true do
-    state :off_sale
+    #
+    # :off_sale denotes that the tickets are not publicly available for purchase
+    # The tickets may still be sold by other means, such as the producer selling into a hold.
+    # Tickets may be off_Sale for a variety of reasons: seats are held, tickets explicitly
+    # set to off_sale, seats are killed, ticket refunded but not returned to inventory.
+    #
+    state :off_sale 
+
+    #
+    # An :on_sale ticket is available for purchase through the storefront
+    #
     state :on_sale
+    
+    #
+    # A :sold ticket has been purchased by a buyer
+    #
     state :sold
+    
+    #
+    # A :comped ticket was given to a patron for no charge. It's similar to a $0 sold ticket
+    # but there are enough differences that it merited its own state
+    #
     state :comped
 
     event(:on_sale)                                   { transitions :from => [ :on_sale, :off_sale ],   :to => :on_sale   }
     event(:off_sale)                                  { transitions :from => [ :on_sale, :off_sale ],   :to => :off_sale  }
     event(:exchange, :success => :record_exchange)    { transitions :from => [ :on_sale, :off_sale ],   :to => :sold      }
-    event(:sell, :success => :record_sale)            { transitions :from => [ :on_sale ],              :to => :sold      }
+    event(:sell, :success => :record_sale)            { transitions :from => [ :on_sale, :off_sale ],              :to => :sold      }
     event(:comp, :success => :record_comp)            { transitions :from => [ :on_sale, :off_sale ],   :to => :comped    }
     event(:return_to_inventory)                       { transitions :from => [ :comped, :sold ],        :to => :on_sale   }
     event(:return_off_sale)                           { transitions :from => [ :comped, :sold ],        :to => :off_sale  }
@@ -225,12 +245,15 @@ class Ticket < ActiveRecord::Base
     not committed?
   end
 
-  #Bulk creation of tickets should use this method to ensure all tickets are created the same
-  #Reminder that this returns a ActiveRecord::Import::Result, not an array of tickets
+  #
+  # Bulk creation of tickets should use this method to ensure all tickets are created the same
+  # Reminder that this returns a ActiveRecord::Import::Result, not an array of tickets
+  #
   def self.create_many(show, section, quantity, on_sale = false)
     new_tickets = []
+
     quantity.times do
-      new_tickets << build_one(show, section, quantity, on_sale)
+      new_tickets << build_one(show, section, on_sale)
     end
 
     result = Ticket.import(new_tickets)
@@ -242,11 +265,12 @@ class Ticket < ActiveRecord::Base
   # This method does not refresh show stats
   # Callers should do that manually with show.delay.refresh_stats
   #
-  def self.build_one(show, section, quantity, on_sale = false)
+  def self.build_one(show, section, on_sale = false, seat=nil)
     t = Ticket.new({
       :venue => show.event.venue.name,
       :section => section,
     })
+    t.seat = seat
     t.show = show
     t.organization = show.organization
     t.set_uuid