artfully_ose 1.1.0 → 1.2.0.alpha.1

data/app/models/seasonal_membership_type.rb

@@ -0,0 +1,3 @@
+class SeasonalMembershipType < MembershipType
+  validates :starts_at, :ends_at, :presence => true
+end

data/app/models/section.rb

@@ -1,24 +1,28 @@
 class Section < ActiveRecord::Base
   include Ticket::Foundry
-  foundry :with => lambda { { :section_id => id, :price => price, :count => capacity } }
+  attr_accessor :skip_create_first_ticket_type
+  foundry :with => lambda { { :section_id => id, :count => capacity } }
 
-  attr_accessible :name, :capacity, :price, :chart_id, :old_mongo_id, :description
+  attr_accessible :name, :capacity, :price, :chart_id, :old_mongo_id, :description, :ticket_types_attributes, :members
   delegate :show, :to => :chart
 
+  has_many :ticket_types, :order => 'price DESC'
+  accepts_nested_attributes_for :ticket_types, :allow_destroy => true
+
   belongs_to :chart
   has_many :tickets
 
   validates :name, :presence => true
 
-  validates :price, :presence => true,
-                    :numericality => true
-
   validates :capacity,  :presence => true,
                         :numericality => { :less_than_or_equal_to => 2000 }
 
   validates :description, :length => { :maximum => 500 }
   
+  after_create :create_first_ticket_type, :unless => lambda { @skip_create_first_ticket_type == true }
+
   # Each channel needs its own boolean column in the sections table.
+  # @@channels = { :storefront => "S", :box_office => "B", :members => "M"}
   @@channels = { :storefront => "S", :box_office => "B"}
   @@channels.each do |channel_name, icon|
     attr_accessible channel_name
@@ -31,41 +35,69 @@ class Section < ActiveRecord::Base
     @@channels
   end
 
-  def dup!
-    Section.new(self.attributes.reject { |key, value| key == 'id' })
+  def summarize
+    tickets = Ticket.where(:section_id => id)
+    @summary = SectionSummary.for_tickets(tickets)
+  end
+
+  def summary
+    @summary || summarize
   end
   
-  def self.price_to_cents(price_in_dollars)
-    (price_in_dollars.to_f * 100).to_i
+  def create_first_ticket_type
+    if self.ticket_types.empty?
+      self.ticket_types.build({ :name     => "General Admission",
+                                :price    => 0,
+                                :limit    => nil},
+                                :without_protection => true).save
+    end
   end
 
-  def summarize
-    tickets = Ticket.where(:section_id => id)
-    @summary = SectionSummary.for_tickets(tickets)
+  def ticket_types_for(member = nil)
+    types = []
+
+    # Add storefront types regardless of anything
+    types << ticket_types.storefront
+    unless member.nil?
+
+      #Add "unrestricted member" ticket_types that aren't tied to a particular membership type
+      types << ticket_types.members.select{|ticket_type| !ticket_type.member_ticket?} unless member.nil?
+
+      #Now add member ticket_types that apply to this particular member
+      membership_type_ids = member.nil? ? [] : member.current_membership_types.collect(&:id)
+      types << ticket_types.select{|ticket_type| ticket_type.members && membership_type_ids.include?(ticket_type.membership_type_id) }
+    end
+
+    types.flatten.uniq
+  end
+
+  def dup!    
+    attrs = self.attributes.reject { |key, value| key == 'id' }
+    self.class.new(attrs).tap do |copy|
+      copy.ticket_types = self.ticket_types.collect { |ticket_type| ticket_type.dup! }
+    end
   end
   
   def put_on_sale(qty = 0)
     tickets.off_sale.limit(qty).each do |t|
       t.put_on_sale
     end
+    show.refresh_stats
   end
   
   def take_off_sale(qty = 0)
     tickets.on_sale.limit(qty).each do |t|
       t.take_off_sale
     end
+    show.refresh_stats
   end
   
   def available
     Ticket.on_sale.where(:section_id => self.id).where(:cart_id => nil).count
   end
 
-  def summary
-    @summary || summarize
-  end
-
   def as_json(options = {})
     options ||= {}
-    super(:methods => :summary).merge(options)
+    super(:methods => [:summary, :ticket_types]).merge(options)
   end
 end

data/app/models/segment.rb

@@ -1,5 +1,5 @@
 class Segment < ActiveRecord::Base
-  attr_accessible :organization, :search_id, :name
+  attr_accessible :organization, :search, :search_id, :name
 
   belongs_to :organization
   belongs_to :search

data/app/models/show.rb

@@ -1,13 +1,15 @@
 class Show < ActiveRecord::Base
-  include Ticket::Foundry  
+  include Ticket::Foundry
   include Ticket::Reporting
   include ActiveRecord::Transitions
   include Ext::Resellable::Show
   include Ext::Integrations::Show
   include Ext::Uuid
 
-  attr_accessible :datetime, :event_id, :chart_id, :organization_id, :old_mongo_id
-  
+  attr_accessible :datetime, :event_id, :chart_id, :organization_id, :old_mongo_id, :cached_stats
+  store :cached_stats, :accessors => [ :capacity, :on_sale, :off_sale, :open, :sold, :comped, :local_datetime, :offset, :time_zone, :iana_time_zone ]
+
+
   belongs_to :organization
   belongs_to :event
   belongs_to :chart, :autosave => true
@@ -16,8 +18,10 @@ class Show < ActiveRecord::Base
 
   has_many :settlements
   has_many :items
-  
-  before_destroy :destroyable?
+  has_many :ticket_types
+
+  before_destroy  :destroyable?
+  after_create    :update_ticket_types
 
   has_many :reseller_attachments, :as => :attachable
 
@@ -42,7 +46,7 @@ class Show < ActiveRecord::Base
   delegate :free?, :to => :event
 
   state_machine do
-    
+
     #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
@@ -58,12 +62,54 @@ class Show < ActiveRecord::Base
   def go!(and_publish = true)
     return false if !valid?
     transaction do
-      build!    
+      build!
       and_publish ? publish! : unpublish!
       save
     end
   end
 
+  def applies_to_pass?(pass)
+    epts = EventsPassType.active
+                  .where(:organization_id => self.organization.id)
+                  .where(:event_id => self.event.id)
+                  .where(:pass_type_id => pass.pass_type.id).first
+
+    return false if epts.blank?
+
+    return !epts.excluded_shows.include?(self.id)
+  end
+
+  #
+  # Run synchronously only with great care. 
+  #
+  def refresh_stats
+    tickets.reload
+
+    self.local_datetime = self.datetime_local_to_event.to_s unless self.event.nil?
+
+    self.capacity = self.glance.available.capacity
+    self.on_sale  = self.glance.available.on_sale
+    self.off_sale = self.glance.available.off_sale
+    self.sold     = self.glance.sold.total
+    self.comped   = self.glance.comped.total
+    self.open     = self.glance.available.open
+
+    unless self.event.time_zone.nil?
+      self.offset         = ActiveSupport::TimeZone.create(self.event.time_zone).parse(self.local_datetime).formatted_offset
+    end
+    
+    self.time_zone      = self.event.time_zone
+    self.iana_time_zone = ActiveSupport::TimeZone::MAPPING[self.event.time_zone]
+
+    self.save(:validate => false)
+    self.event.delay.refresh_stats
+    self.cached_stats
+  end
+
+  def parsed_local_datetime
+    @parsed_local_datetime = (DateTime.parse(self.local_datetime) rescue self.datetime_local_to_event)
+  end
+
   def create_and_on_sale_tickets
     create_tickets
     bulk_on_sale(:all)
@@ -72,11 +118,11 @@ class Show < ActiveRecord::Base
   def unscoped_event
     ::Event.unscoped.find(event_id)
   end
-  
+
   def imported?
     unscoped_event.imported?
   end
-  
+
   def event_deleted?
     !unscoped_event.deleted_at.nil?
   end
@@ -97,6 +143,14 @@ class Show < ActiveRecord::Base
     @tickets_comped ||= tickets.select { |ticket| ticket.comped? }
   end
 
+  def tickets_validated
+    tickets.where(:validated => true).count
+  end
+
+  def to_s
+    show_time
+  end
+
   def self.next_datetime(show)
     show.nil? ? future(Time.now.beginning_of_day + 20.hours) : future(show.datetime_local_to_event + 1.day)
   end
@@ -105,10 +159,6 @@ class Show < ActiveRecord::Base
     published? or unpublished?
   end
 
-  def time_zone
-    @time_zone ||= event.time_zone
-  end
-
   def load(attrs)
     super(attrs)
     set_attributes(attrs)
@@ -118,6 +168,7 @@ class Show < ActiveRecord::Base
     copy = Show.new(self.attributes.reject { |key, value| key == 'id' || key == 'uuid' || key == 'state' })
     copy.event = self.event
     copy.datetime = copy.datetime + 1.day
+    copy.chart = self.chart.dup!
     copy
   end
 
@@ -132,10 +183,20 @@ class Show < ActiveRecord::Base
       "state" => state,
       "show_time" => show_time,
       "datetime" => datetime_local_to_event,
-      "destroyable" => destroyable?
+      "destroyable" => destroyable?,
+      "chart" => chart_for("storefront", options[:organization_id]).as_json(options)
     }
   end
 
+  #
+  # For a single show being displayed in the widget
+  #
+  def as_widget_json(options = {})
+    as_json.merge(:event => event.as_json,
+                  :venue => event.venue.as_json,
+                  :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)
@@ -170,9 +231,18 @@ class Show < ActiveRecord::Base
     settleables
   end
 
+  #
+  # Horribly inefficient. Don't use with a list of shows.
+  #
   def destroyable?
     (tickets_comped + tickets_sold).empty? && items.empty?
   end
+  
+  def delayed_destroy
+    return false unless destroyable?
+    Delayed::Job.enqueue(DestroyShowJob.new(self))
+    true
+  end
 
   def live?
     (tickets_comped + tickets_sold).any?
@@ -198,8 +268,8 @@ class Show < ActiveRecord::Base
     tickets.select(&:compable?)
   end
 
-  def as_widget_json(options = {})
-    as_json.merge(:event => event.as_json, :venue => event.venue.as_json, :chart => chart.as_json)
+  def sections_for(member)
+    member.nil? ? self.chart.sections.storefront : self.chart.sections.members
   end
 
   def <=>(obj)
@@ -216,6 +286,13 @@ class Show < ActiveRecord::Base
     self.ticket_offers.inject(0) { |sum, to| sum + to.sold }
   end
 
+  #
+  # We can't do this until the show is saved, obviously
+  #
+  def update_ticket_types
+    TicketType.set_show(self)
+  end
+
   private
 
   def self.future(date)

data/app/models/slices.rb

@@ -12,27 +12,40 @@ class Slices
                  :ticket_type_proc, 
                  :order_location_proc,
                  :discount_code_proc,
-                 :first_time_buyer_proc
+                 :first_time_buyer_proc,
+                 :validated_proc
 
   self.payment_method_proc = Proc.new do |items|
     payment_method_map = {}
     items.each do |item|
+      next if item.refund? || item.refunded? || item.exchanged?
       item_array = payment_method_map[item.order.payment_method]
       item_array ||= []
-      item_array << item unless item.refund? || item.refunded? || item.exchanged?
+      item_array << item
       payment_method_map[item.order.payment_method] = item_array
     end
     payment_method_map.delete_if{ |k,v| v.empty? }
   end
 
+  self.validated_proc = Proc.new do |items|
+    validated_map = {}
+    items.each do |item|
+      next if item.refund? || item.refunded? || item.exchanged?
+      kee = (item.product.validated? ? "VALIDATED" : "NOT VALIDATED")
+      item_array = validated_map.fetch(kee, [])
+      item_array << item
+      validated_map[kee] = item_array
+    end
+    validated_map.delete_if{ |k,v| v.empty? }
+  end
+
   self.ticket_type_proc = Proc.new do |items|
     ticket_type_map = {}
     items.each do |item|
-      puts item.product.section.name
-      item_array = ticket_type_map[item.product.section.name]
-      item_array ||= []
-      item_array << item unless item.refund? || item.refunded? || item.exchanged?
-      ticket_type_map[item.product.section.name] = item_array
+      next if item.refund? || item.refunded? || item.exchanged?
+      item_array = ticket_type_map.fetch(item.product.ticket_type.name, [])
+      item_array << item
+      ticket_type_map[item.product.ticket_type.name] = item_array
     end
     ticket_type_map.delete_if{ |k,v| v.empty? }
   end
@@ -40,10 +53,11 @@ class Slices
   self.order_location_proc = Proc.new do |items|
     order_location_map = {}
     items.each do |item|
+      next if item.refund? || item.refunded? || item.exchanged?
       order_location = item.order.original_order.location
       item_array = order_location_map[order_location]
       item_array ||= []
-      item_array << item unless item.refund? || item.refunded? || item.exchanged?
+      item_array << item
       order_location_map[order_location] = item_array
     end
     order_location_map.delete_if{ |k,v| v.empty? }
@@ -52,10 +66,11 @@ class Slices
   self.discount_code_proc = Proc.new do |items|
     discounts_code_map = {}
     items.each do |item|
+      next if item.refund? || item.refunded? || item.exchanged?
       code = item.discount.try(:code) || "NO DISCOUNT"
       item_array = discounts_code_map[code]
       item_array ||= []
-      item_array << item unless item.refund? || item.refunded? || item.exchanged?
+      item_array << item 
       discounts_code_map[code] = item_array
     end
     discounts_code_map.delete_if{ |k,v| v.empty? }
@@ -67,6 +82,7 @@ class Slices
   self.first_time_buyer_proc = Proc.new do |items|
     first_time_buyer_map = {}
     items.each do |item|
+      next if item.refund? || item.refunded? || item.exchanged?
       previous_action = GetAction.where(:person_id => item.order.person.id)
                                  .where('occurred_at < ?', item.order.created_at)
                                  .first
@@ -74,7 +90,7 @@ class Slices
       kee = (previous_action.nil? ? "FIRST" : "RETURNING")
       item_array = first_time_buyer_map[kee]
       item_array ||= []
-      item_array << item unless item.refund? || item.refunded? || item.exchanged?
+      item_array << item
       first_time_buyer_map[kee] = item_array
     end
     first_time_buyer_map.delete_if{ |k,v| v.empty? }

data/app/models/statement.rb

@@ -26,7 +26,8 @@ class Statement
                 :payment_method_rows,
                 :order_location_rows,
                 :ticket_type_rows,
-                :discount_rows
+                :discount_rows,
+                :pass_rows
   
   def self.for_show(show, imported=false)
     if show.nil?
@@ -39,7 +40,6 @@ class Statement
       statement.datetime          = show.datetime_local_to_event
       statement.tickets_sold      = show.tickets.select{|t| t.sold?}.size
       statement.tickets_comped    = show.tickets.select{|t| t.comped?}.size
-      statement.potential_revenue = show.tickets.inject(0) { |total_price, ticket| total_price += ticket.price }
       statement.gross_revenue     = show.items.inject(0) { |gross, item| gross += item.price }
       statement.net_revenue       = show.items.inject(0) { |net, item| net += item.net }
       statement.processing        = statement.gross_revenue - statement.net_revenue
@@ -82,6 +82,7 @@ class Statement
       end
 
       statement.build_discount_rows(show.items)
+      statement.build_pass_rows(show.items)
       statement.build_ticket_type_rows(show, show.items)
     end
   end
@@ -92,14 +93,17 @@ class Statement
   def build_ticket_type_rows(show, items)
     self.ticket_type_rows         = {}
 
-    show.chart.sections.each do |section|
-      self.ticket_type_rows[section.name] = TicketTypeRow.new(section.name)
+    show.chart.ticket_types.each do |ticket_type|
+      self.ticket_type_rows[ticket_type.name] = TicketTypeRow.new(ticket_type)
     end
 
     items.each do |item|
-      row = self.ticket_type_rows[item.product.section.name] || TicketTypeRow.new(item.product.section.name)
-      row << item
-      self.ticket_type_rows[item.product.section.name] = row
+      #refunded items now have nil ticket types
+      unless item.product.ticket_type.nil?
+        row = self.ticket_type_rows[item.product.ticket_type.name] || TicketTypeRow.new(item.product.ticket_type)
+        row << item
+        self.ticket_type_rows[item.product.ticket_type.name] = row
+      end
     end
   end
 
@@ -114,6 +118,17 @@ class Statement
       end
     end
   end
+
+  def build_pass_rows(items)
+    self.pass_rows         = {}
+    items.each do |item|
+      unless item.pass.nil?
+        row = self.pass_rows[item.pass.pass_type.name] || PassRow.new(item.pass.pass_type.name)
+        row << item
+        self.pass_rows[item.pass.pass_type.name] = row
+      end
+    end
+  end
   
   module Row
     attr_accessor :tickets, 
@@ -138,10 +153,11 @@ class Statement
   
   class TicketTypeRow
     include Row
-    attr_accessor   :ticket_type
+    attr_accessor   :ticket_type, :member_ticket
     
     def initialize(ticket_type)
-      self.ticket_type = ticket_type
+      self.ticket_type = ticket_type.name
+      self.member_ticket = ticket_type.member_ticket
       self.tickets = 0
       self.gross = 0
       self.processing = 0
@@ -164,6 +180,19 @@ class Statement
     end
   end
   
+  class PassRow
+    include Row
+    attr_accessor   :pass_type_name
+    
+    def initialize(pass_type_name)
+      self.pass_type_name = pass_type_name
+      self.tickets = 0
+      self.gross = 0
+      self.processing = 0
+      self.net = 0
+    end
+  end
+  
   class OrderLocationRow
     include Row
     attr_accessor   :order_location