artfully_ose 1.0.0.rc4 → 1.1.0.rc1

data/app/models/statement.rb

@@ -1,18 +1,41 @@
+###
+#
+# Statement uses items from a show to calculate things like gross, net, and
+# cut the data up into various sections.  The reason we don't use tickets is:
+# 
+# * Item is the table of record for revenue
+# * a Ticket can have many items (refunds, exchanges, etc...) It's awkward (and db intensive)
+#   to get the sold_item for a ticket
+#
+# The downside is that this approach requires a bit of hoop jumping in Row (see if, elsif, else block)
+# which is indeed ugly.
+#
+###
 class Statement  
+  include Ext::Due
+
   attr_accessor :datetime, 
                 :tickets_sold, 
                 :tickets_comped, 
                 :potential_revenue, 
                 :gross_revenue, 
                 :processing, 
-                :net_revenue
+                :net_revenue,
+                :cc_net,
+                :settled,
+                :payment_method_rows,
+                :order_location_rows,
+                :ticket_type_rows,
+                :discount_rows
   
-  def self.for_show(show, organization)
-    if show.nil? || organization.nil?
+  def self.for_show(show, imported=false)
+    if show.nil?
       return new
     end
     
     new.tap do |statement|
+
+      # Some of this overlaps with Ticket::Glance.  Consider refactoring to combine the two.
       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
@@ -20,6 +43,150 @@ class Statement
       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
+      
+      statement.calculate_due(show, imported)
+
+      #
+      # PAYMENT METHOD
+      #
+      payment_method_hash         = show.items.group_by { |item| item.order.payment_method }
+      statement.payment_method_rows         = {}
+      
+      # Initialize with the three common payment types
+      statement.payment_method_rows[::CreditCardPayment.payment_method.downcase] = PaymentTypeRow.new(::CreditCardPayment.payment_method)
+      statement.payment_method_rows[::CashPayment.payment_method.downcase] = PaymentTypeRow.new(::CashPayment.payment_method)
+      statement.payment_method_rows[::CompPayment.payment_method.downcase] = PaymentTypeRow.new(::CompPayment.payment_method)
+      
+      payment_method_hash.each do |payment_method, items|
+        payment_method = (payment_method.try(:downcase) || "")
+        row = statement.payment_method_rows[payment_method] || PaymentTypeRow.new(payment_method)
+        items.each {|item| row << item}
+        statement.payment_method_rows[payment_method] = row
+      end
+      
+      #
+      # ORDER LOCATION
+      #  
+      order_location_hash         = show.items.group_by do |item| 
+        item.order.original_order.location 
+      end
+      
+      statement.order_location_rows = {}
+      statement.order_location_rows[::WebOrder.location]        = OrderLocationRow.new(::WebOrder.location)
+      statement.order_location_rows[BoxOffice::Order.location]  = OrderLocationRow.new(BoxOffice::Order.location)
+      
+      order_location_hash.each do |order_location, items|
+        row = statement.order_location_rows[order_location] || OrderLocationRow.new(order_location)
+        items.each {|item| row << item}
+        statement.order_location_rows[order_location] = row
+      end
+
+      statement.build_discount_rows(show.items)
+      statement.build_ticket_type_rows(show, show.items)
+    end
+  end
+
+  #
+  # TODO: These are super-related to the procs in class Slices.  Get these two on the same page and DRY it up
+  #
+  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)
+    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
+    end
+  end
+
+  def build_discount_rows(items)
+    self.discount_rows         = {}
+    items.each do |item|
+      unless item.discount.nil?
+        row = self.discount_rows[item.discount.code] || DiscountRow.new(item.discount.code, item.discount.to_s)
+        row << item
+        row.discount += (item.original_price - item.price)
+        self.discount_rows[item.discount.code] = row
+      end
+    end
+  end
+  
+  module Row
+    attr_accessor :tickets, 
+                  :gross,
+                  :processing,
+                  :net
+    
+    def<<(item)
+      if item.refund?
+        self.tickets = self.tickets - 1
+      elsif item.exchanged? || item.return?
+        #Noop
+      else
+        self.tickets = self.tickets + 1   
+      end
+      
+      self.gross        = self.gross + item.price
+      self.processing   = self.processing + (item.realized_price - item.net)
+      self.net          = self.net + item.net
+    end
+  end
+  
+  class TicketTypeRow
+    include Row
+    attr_accessor   :ticket_type
+    
+    def initialize(ticket_type)
+      self.ticket_type = ticket_type
+      self.tickets = 0
+      self.gross = 0
+      self.processing = 0
+      self.net = 0
+    end
+  end
+  
+  class DiscountRow
+    include Row
+    attr_accessor   :discount_code, :type, :discount
+    
+    def initialize(discount_code, type)
+      self.discount_code = discount_code
+      self.type = type
+      self.tickets = 0
+      self.gross = 0
+      self.processing = 0
+      self.net = 0
+      self.discount = 0
+    end
+  end
+  
+  class OrderLocationRow
+    include Row
+    attr_accessor   :order_location
+    
+    def initialize(order_location)
+      self.order_location = order_location
+      self.tickets = 0
+      self.gross = 0
+      self.processing = 0
+      self.net = 0
+    end
+  end
+  
+  class PaymentTypeRow
+    include Row
+    attr_accessor   :payment_method
+    
+    def initialize(payment_method)
+      self.payment_method = payment_method
+      self.tickets = 0
+      self.gross = 0
+      self.processing = 0
+      self.net = 0
     end
   end
 end

data/app/models/temp_discount.rb

@@ -0,0 +1,14 @@
+# only exsist for mockuping up the discount form
+# remove after Discount and DiscountSections model is created
+
+class TempDiscount < Event
+  attr_accessor :code, :active, :promotion_type, :minimum_purchase, :maximum_purchase, :show_ids, :limit, :unlimited_capacity
+
+  has_many :discount_sections
+end
+
+class DiscountSection < Section
+  attr_accessor :temp_discount_id, :section, :section_id
+
+  attr_accessible :section
+end

data/app/models/ticket.rb

@@ -1,20 +1,27 @@
 class Ticket < ActiveRecord::Base
-
   include ActiveRecord::Transitions
+  include Ext::Resellable::Ticket
+  include Ext::Integrations::Ticket
+  include Ticket::Pricing
+  include Ticket::Transfers
+  include Ticket::SaleTransitions
+  extend ActionView::Helpers::TextHelper
   
-  attr_accessible :section_id, :section, :price, :venue
+  attr_accessible :section_id, :section, :price, :venue, :cart_price
 
   belongs_to :buyer, :class_name => "Person"
   belongs_to :show
   belongs_to :organization
   belongs_to :section
-
   belongs_to :cart
+  belongs_to :discount
   
   has_many :items, :foreign_key => "product_id"
 
   delegate :event, :to => :show
 
+  before_validation :set_cart_price
+
   def self.sold_after(datetime)
     sold.where("sold_at > ?", datetime)
   end
@@ -33,12 +40,13 @@ class Ticket < ActiveRecord::Base
     state :sold
     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 => :metric_exchanged)  { transitions :from => [ :on_sale, :off_sale ],   :to => :sold    }
-    event(:sell, :success => :metric_sold)      { transitions :from => :on_sale,                  :to => :sold      }
-    event(:comp)      { transitions :from => [ :on_sale, :off_sale ],   :to => :comped    }
-    event(:do_return) { transitions :from => [ :comped, :sold ],        :to => :on_sale   }
+    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(: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  }
   end
 
   def datetime
@@ -53,6 +61,16 @@ class Ticket < ActiveRecord::Base
     where(:state => [:off_sale, :on_sale])
   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
+  end
+
+  #
+  # Unfortunately named.  This will return available tickets, not a count of available tickets
+  # as is the idiom elsewhere in the app
+  #
   def self.available(params = {}, limit = 4)
     conditions = params.dup
     conditions[:state] ||= :on_sale
@@ -71,8 +89,7 @@ class Ticket < ActiveRecord::Base
   def sold_item
     items.select(&:purchased?).first ||
     items.select(&:settled?).first ||
-    items.select(&:comped?).first ||
-    items.select(&:exchangee?).first
+    items.select(&:comped?).first
   end
   
   def special_instructions
@@ -99,66 +116,6 @@ class Ticket < ActiveRecord::Base
     !expired?
   end
 
-  def take_off_sale
-    begin
-      off_sale!
-    rescue Transitions::InvalidTransition
-      return false
-    end
-  end
-
-  def put_on_sale
-    begin
-      on_sale!
-    rescue Transitions::InvalidTransition
-      return false
-    end
-  end
-
-  def sell_to(buyer, time=Time.now)
-    begin
-      self.buyer = buyer
-      self.sold_price = self.price
-      self.sold_at = time
-      self.sell!
-    rescue Transitions::InvalidTransition
-      return false
-    end
-  end
-
-  def exchange_to(buyer, time=Time.now)
-    begin
-      self.buyer = buyer
-      self.sold_price = 0
-      self.sold_at = time
-      self.exchange!
-    rescue Transitions::InvalidTransition => e
-      puts e
-      return false
-    end
-  end
-
-  def comp_to(buyer, time=Time.now)
-    begin
-      self.buyer = buyer
-      self.sold_price = 0
-      self.sold_at = time
-      self.comp!
-    rescue Transitions::InvalidTransition => e
-      puts e
-      return false
-    end
-  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
-  end
-
   def committed?
     sold? or comped?
   end
@@ -187,80 +144,31 @@ class Ticket < ActiveRecord::Base
     super if destroyable?
   end
 
-  def return!
-    self.buyer = nil
-    self.sold_price = nil
-    self.sold_at = nil
-    self.buyer_id = nil
-    save
-    do_return!
-  end
-
-  def self.put_on_sale(tickets)
-    return false if tickets.blank?
-    attempt_transition(tickets, :on_sale) do
-      Ticket.update_all({ :state => :on_sale }, { :id => tickets.collect(&:id)})
-    end
-  end
-
-  def self.take_off_sale(tickets)
-    return false if tickets.blank?
-    attempt_transition(tickets, :off_sale) do
-      Ticket.update_all({ :state => :off_sale }, { :id => tickets.collect(&:id)})
-    end
-  end
-
   def repriceable?
     not committed?
   end
 
-  def reseller
-    order =
-      Reseller::Order.
-        includes(:organization, :items).
-        where("items.product_type" => "Ticket", "items.product_id" => id).
-        first
-
-    order.organization if order
-  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
   def self.create_many(show, section, quantity, on_sale = false)
     new_tickets = []
-    (0..quantity-1).each do
-      t = Ticket.new({
-        :venue => show.event.venue.name,
-        :price => section.price,
-        :section => section,
-      })
-      t.show = show
-      t.organization = show.organization
-      t.state = 'on_sale' if on_sale
-      new_tickets << t
+    quantity.times do
+      new_tickets << build_one(show, section, section.price, quantity, on_sale)
     end
     
     result = Ticket.import(new_tickets)
     result
   end
-
-  private
-
-    def self.attempt_transition(tickets, state)
-      begin
-        tickets.map(&state)
-        yield
-      rescue Transitions::InvalidTransition
-        logger.info "Trying to transition ticket [#{}] on_sale, transition failed"
-      end
-    end
-
-    def metric_sold
-      RestfulMetrics::Client.add_metric(ENV["RESTFUL_METRICS_APP"], "ticket_sold", 1)
-    end
-
-    def metric_exchanged
-      RestfulMetrics::Client.add_metric(ENV["RESTFUL_METRICS_APP"], "ticket_exchanged", 1)
-    end
-
+  
+  def self.build_one(show, section, price, quantity, on_sale = false)
+    t = Ticket.new({
+      :venue => show.event.venue.name,
+      :price => price,
+      :section => section,
+    })
+    t.show = show
+    t.organization = show.organization
+    t.state = 'on_sale' if on_sale
+    t
+  end
 end

data/app/models/ticket/pricing.rb

@@ -0,0 +1,45 @@
+module Ticket::Pricing
+  extend ActiveSupport::Concern
+
+  def remove_from_cart
+    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!
+    return false if sold?
+    
+    self.cart_price = self.price
+    self.discount = nil
+    self.sold_price = 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
+    self.save
+  end
+
+  def set_cart_price
+    self.cart_price ||= self.price
+  end
+
+  def cart_price
+    self[:cart_price] || self.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
+  end
+end