artfully_ose 1.1.0 → 1.2.0.alpha.1

data/app/models/suggested_household.rb

@@ -0,0 +1,24 @@
+class SuggestedHousehold < ActiveRecord::Base
+  attr_accessible :ids, :ignored
+
+  def self.with_people(people)
+    ids = people.map(&:id).sort.join(',')
+    where(:ids => ids).first
+  end
+
+  def self.create_with_people(people)
+    ids = people.map(&:id).sort.join(',')
+    create(:ids => ids)
+  end
+
+  def self.find_or_create_with_people(people)
+    ids = people.map(&:id).sort.join(',')
+    matches = where(:ids => ids)
+    matches.first ? matches.first : SuggestedHousehold.create_with_people(people)
+  end
+
+  def individuals
+    Individual.where(:id => ids.split(','))
+  end
+
+end

data/app/models/sundial.rb

@@ -0,0 +1,12 @@
+#
+# Utility methods that alleviate the pain of dealign with timezones, midnight, etc...
+#
+class Sundial
+  def self.in_time_zone(organization, time_string)
+    ActiveSupport::TimeZone.create(organization.time_zone).parse(time_string)
+  end
+
+  def self.midnightish(organization, time_string)
+    in_time_zone(organization, time_string) + 1.day - 1.minute
+  end
+end

data/app/models/ticket.rb

@@ -1,27 +1,39 @@
-class Ticket < ActiveRecord::Base
+ class Ticket < ActiveRecord::Base
   include ActiveRecord::Transitions
   include Ext::Resellable::Ticket
   include Ext::Integrations::Ticket
+  include Ticket::Locker
   include Ticket::Pricing
   include Ticket::Transfers
   include Ticket::SaleTransitions
+  include Ext::Uuid
   extend ActionView::Helpers::TextHelper
-  
-  attr_accessible :section_id, :section, :price, :venue, :cart_price
+
+  class TicketAlreadyValidated < StandardError; end
+
+  attr_accessible :section_id, :section, :venue, :cart_price
 
   belongs_to :buyer, :class_name => "Person"
   belongs_to :show
   belongs_to :organization
   belongs_to :section
   belongs_to :cart
+  belongs_to :pass
   belongs_to :discount
+  belongs_to :action, :foreign_key => "validated_action_id", :class_name => "GoAction"
+
+  #
+  # This refs the ticket_type that the ticket was sold under, NOT an array of ticket types available
+  #
+  belongs_to :ticket_type
   
-  has_many :items, :foreign_key => "product_id"
+  has_many :items, :as => :product
 
-  delegate :event, :to => :show
+  has_attached_file :qr_code, TICKET_QR_STORAGE
 
-  before_validation :set_cart_price
+  delegate :url, :to => :qr_code, :prefix => true
 
+  delegate :event, :to => :show
   def self.sold_after(datetime)
     sold.where("sold_at > ?", datetime)
   end
@@ -34,6 +46,9 @@ class Ticket < ActiveRecord::Base
   scope :unplayed,    lambda { joins(:show).merge(Show.unplayed) }
   scope :resellable,  lambda { where(:state => "on_sale") }
 
+  #Used when unlocking tickets. We don't want to unlocked sold or comped tickets.
+  scope :uncommitted,   where("state != 'sold'").where("state != 'comped'")
+
   state_machine do
     state :off_sale
     state :on_sale
@@ -53,8 +68,23 @@ class Ticket < ActiveRecord::Base
     show.datetime_local_to_event
   end
 
+  #
+  # This intentionally returns nil if the ticket does not yet have a ticket_type assigned
+  #
+  def ticket_type_price
+    self.ticket_type.try(:price)
+  end
+
+  #
+  # This is here so that Item.for can add tickets. 
+  # Ticket is composing what it means to be turned into an item
+  #
+  def price
+    ticket_type_price
+  end
+
   def as_json(options = {})
-    super(options).merge!({:section => section})
+    super(options).merge!({:ticket_type => ticket_type}).except!("section_id", "buyer_id", "show_id", "ticket_type_id", "cart_id", "discount_id", "organization_id", "old_mongo_id")
   end
 
   def self.unsold
@@ -62,9 +92,17 @@ class Ticket < ActiveRecord::Base
   end
 
   def self.to_sentence(tickets)
-    shows_string = tickets.map(&:show).uniq.length > 1 ? ", multiple shows" : " on " + I18n.localize(tickets.first.show.datetime_local_to_event, :format => :day_time_at)
-    events_string = tickets.map(&:show).map(&:event).uniq.length > 1 ? "multiple events" : tickets.first.show.event.name + shows_string
-    pluralize(tickets.length, "ticket") + " to " + events_string
+    if tickets.any?
+      shows_string = tickets.map(&:show).uniq.length > 1 ? ", multiple shows" : " on " + I18n.localize(tickets.first.show.datetime_local_to_event, :format => :day_time_at)
+      events_string = tickets.map(&:show).map(&:event).uniq.length > 1 ? "multiple events" : tickets.first.show.event.name + shows_string
+      pluralize(tickets.length, "ticket") + " to " + events_string
+    else
+      "No tickets"
+    end
+  end
+
+  def order_summary_description
+    self.try(:ticket_type).try(:name) || ""
   end
 
   #
@@ -93,13 +131,27 @@ class Ticket < ActiveRecord::Base
   end
   
   def special_instructions
-    sold_item.nil? ? nil : sold_item.order.special_instructions
+    sold_item.try(:order).try(:special_instructions)
   end
 
-  def self.fee
+  def notes
+    sold_item.try(:order).try(:notes)
+  end
+
+  def can_be_assigned_to(ticket_type)
+    return false if ticket_type.nil?
+    ticket_type = TicketType.find(ticket_type) unless ticket_type.is_a? TicketType
+    self.show == ticket_type.show
+  end
+
+  def self.realized_fee
     0
   end
 
+  def realized_fee
+    self.class.realized_fee
+  end
+
   def expired?
     datetime < DateTime.now
   end
@@ -153,22 +205,64 @@ class Ticket < ActiveRecord::Base
   def self.create_many(show, section, quantity, on_sale = false)
     new_tickets = []
     quantity.times do
-      new_tickets << build_one(show, section, section.price, quantity, on_sale)
+      new_tickets << build_one(show, section, quantity, on_sale)
     end
     
     result = Ticket.import(new_tickets)
+    show.refresh_stats
     result
   end
   
-  def self.build_one(show, section, price, quantity, on_sale = false)
+  #
+  # 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)
     t = Ticket.new({
       :venue => show.event.venue.name,
-      :price => price,
       :section => section,
     })
     t.show = show
     t.organization = show.organization
+    t.set_uuid
     t.state = 'on_sale' if on_sale
     t
   end
+
+  def generate_qr_code
+    file = Tempfile.new(['qr-code', '.png'])
+    QRCode.new(self, sold_item.try(:order)).render(file)
+    self.qr_code = file
+
+    # If we don't save the ticket here, paperclip will leak a file handle.
+    # Even though we close our Tempfile below, paperclip copies that into
+    # another Tempfile, and only closes the handle when the ticket is saved.
+    save
+
+    file.close
+  end
+  handle_asynchronously :generate_qr_code
+
+
+  def validate_ticket!(user = nil)
+    if committed? && !validated?
+      Ticket.transaction do
+        self.action = GoAction.for(self.show, self.buyer, Time.now) do |go_action|
+          go_action.creator = user
+        end
+        self.validated = true
+        save
+      end
+    end
+  end
+
+  def unvalidate_ticket!
+    if validated?
+      Ticket.transaction do
+        action.destroy unless self.action.tickets.where(validated:true).count > 1
+        self.validated = false
+        save
+      end
+    end
+  end
 end

data/app/models/ticket/glance.rb

@@ -16,8 +16,7 @@ class Ticket::Glance
   report :available => Ticket::Reports::Available,
          :sold      => Ticket::Reports::Sold,
          :comped    => Ticket::Reports::Comped,
-         :sales     => Ticket::Reports::Sales,
-         :potential => Ticket::Reports::Potential
+         :sales     => Ticket::Reports::Sales
 
   def initialize(parent)
     @parent = parent

data/app/models/ticket/locker.rb

@@ -0,0 +1,51 @@
+module Ticket::Locker
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def lock(tickets, ticket_type, cart)
+      tickets = Array.wrap(tickets)
+
+      #
+      # TODO: blow up if this ticket_type does not apply to this show
+      #
+      Rails.logger.debug(tickets.inspect)
+      Ticket.where(:id => tickets).update_all({ :cart_id        => cart.id, 
+                                                :ticket_type_id => ticket_type.id, 
+                                                :cart_price     => ticket_type.price
+                                                })
+      tickets = Ticket.includes(:ticket_type).where(:id => tickets)
+      Rails.logger.debug(tickets.inspect)
+      cart << tickets
+      ExpireTicketJob.enqueue(tickets.collect(&:id), cart.id)
+      tickets
+    end
+
+    #
+    # We pass cart so that we can ensure we're expiring the right transaction. The ticket could have moved
+    # carts since the job was queued.
+    #
+    # If we come along and expire it, the patron will be bitter.
+    #
+    def unlock(tickets, cart)
+      
+      Ticket.where(:id => tickets)
+            .where(:cart_id => cart)
+            .uncommitted
+            .update_all({ :cart_id        => nil, 
+                          :ticket_type_id => nil,
+                          :pass_id        => nil,  
+                          :cart_price     => nil,
+                          :sold_price     => nil,
+                          :service_fee    => 0,
+                          :discount_id    => nil
+                        })
+    end
+  end
+
+  #
+  # This means ticket is in a cart and not sold.
+  #
+  def locked?
+    !self.cart_id.nil? && !sold? && !comped?
+  end
+end

data/app/models/ticket/pricing.rb

@@ -5,41 +5,49 @@ module Ticket::Pricing
     self.update_column(:cart_id, nil)
   end
 
-  #
-  # This is guarded with sold? Because of the DelayedJob that expires tickets.  The job 
-  # Removes them from cart regardless of state.  If they've been sold, we want that information retained
-  #
-  def reset_price!
+  def prepare_for_cart_change!
     return false if sold?
-    
+    self.discount = nil
+    self.pass = nil
+    self.sold_price = nil
     self.cart_price = self.price
+    self.save
+  end
+
+  def prepare_for_discount!
+    prepare_for_cart_change!
+  end 
+
+  def prepare_for_pass!
+    prepare_for_cart_change!
+  end 
+
+  def reset_price!
+    return false if sold?
     self.discount = nil
+    self.pass     = nil
+    self.ticket_type = nil
     self.sold_price = nil
+    self.cart_price = nil
+    self.service_fee = nil
     self.save
   end 
 
   def exchange_prices_from(old_ticket)
-    self.sold_price = old_ticket.sold_price
-    self.cart_price = old_ticket.sold_price
-    self.discount_id= old_ticket.discount_id
-    self.cart_id = nil
+    raise "Cannot exchange prices without a ticket type set on current ticket" if self.ticket_type.nil?
+    self.sold_price       = old_ticket.sold_price
+    self.cart_price       = old_ticket.sold_price
+    self.discount_id      = old_ticket.discount_id
+    self.service_fee      = old_ticket.service_fee
+    self.cart_id          = nil
     self.save
   end
 
-  def set_cart_price
-    self.cart_price ||= self.price
-  end
-
-  def cart_price
-    self[:cart_price] || self.price
+  def set_cart_price(price)
+    self.cart_price = price
   end
 
   def change_price(new_price)
-    unless self.committed? or new_price.to_i < 0
-      self.price = new_price
-      self.save!
-    else
-      return false
-    end
+    raise "Gone"
   end
 end

data/app/models/ticket/qr_code.rb

@@ -0,0 +1,21 @@
+class Ticket::QRCode
+  def initialize(ticket, order = nil)
+    @ticket = ticket
+    @order = order
+  end
+
+  def text
+    ticket.uuid
+  end
+
+  def render(file)
+    png = RQRCode::QRCode.new(text.to_s, :size => 4, :level => :l).to_img
+    png.resize(150, 150).save(file)
+  end
+
+  private
+
+  delegate :event, :to => :ticket
+
+  attr_reader :ticket, :order
+end

data/app/models/ticket/reports.rb

@@ -26,6 +26,22 @@ module Ticket::Reports
     def total
       tickets.select(&:on_sale?).length
     end
+
+    def on_sale
+      total
+    end
+
+    def off_sale
+      tickets.select(&:off_sale?).length
+    end
+
+    def open
+      on_sale + off_sale
+    end
+
+    def capacity
+      tickets.length
+    end
   end
 
   class Sold < Base
@@ -73,14 +89,4 @@ module Ticket::Reports
       tickets.sold.unplayed.sum(:sold_price)
     end
   end
-
-  class Potential < Base
-    def original
-      tickets.sum(:price)
-    end
-
-    def remaining
-      tickets.unsold.sum(:price)
-    end
-  end
 end

data/app/models/ticket/sale_transitions.rb

@@ -23,6 +23,9 @@ module Ticket::SaleTransitions
       attempt_transition(tickets, :off_sale) do
         Ticket.update_all({ :state => :off_sale }, { :id => tickets.collect(&:id)})
       end
+      Rails.logger.info ("Completed off saling!")
+      tickets.first.show.refresh_stats
+      Rails.logger.info ("Completed off sailing!")
     end
 
     def put_on_sale(tickets)
@@ -30,6 +33,7 @@ module Ticket::SaleTransitions
       attempt_transition(tickets, :on_sale) do
         Ticket.update_all({ :state => :on_sale }, { :id => tickets.collect(&:id)})
       end
+      tickets.first.show.refresh_stats
     end
 
     def attempt_transition(tickets, state)