artfully_ose 1.3.0.pre3 → 1.3.0.pre4

data/app/models/cart.rb

@@ -2,7 +2,7 @@ class Cart < ActiveRecord::Base
   include ActiveRecord::Transitions
   
   has_many :donations, :dependent => :destroy
-  has_many :tickets,      :after_add => :calculate_fees
+  has_many :tickets,      :after_add => [:calculate_fees, :apply_discount_or_pass]
   has_many :memberships,  :after_add => :calculate_fees
   has_many :passes,       :after_add => :calculate_fees
   after_destroy :clear!
@@ -123,6 +123,11 @@ class Cart < ActiveRecord::Base
     FeeCalculator.apply(FeeStrategy.new).to(self)
   end
 
+  def apply_discount_or_pass(obj)
+    self.discount.apply_discount_to_cart(self) if self.discount.present?
+    self.applied_pass.apply_pass_to_cart(self) if self.applied_pass.present?
+  end
+
   def <<(tkts)
     tkts = Array.wrap(tkts)
     tkts.each do |t|

data/app/models/chart.rb

@@ -1,10 +1,11 @@
 class Chart < ActiveRecord::Base
-  include Ticket::Foundry
-  foundry :using => :sections, :with => lambda { { :venue => event.venue.name } }
   attr_accessor :skip_create_first_section
-  attr_accessible :name, :is_template, :event_id, :organization_id, :sections_attributes, :ticket_types_attributes, :organization, :event, :skip_create_first_section
+  attr_accessible :name, :is_template, :event_id, :organization_id, 
+                  :sections_attributes, :ticket_types_attributes, :organization, 
+                  :event, :skip_create_first_section, :venue_id, :public_note
 
   belongs_to :event
+  belongs_to :venue
   belongs_to :organization
   has_one :show
   has_many :sections, :order => 'name DESC'
@@ -17,7 +18,7 @@ class Chart < ActiveRecord::Base
   scope :template, where(:is_template => true)
 
   def as_json(options = {})
-    h = super(options)
+    h = super(options.merge({:except => :venue_id}))
     h[:sections]   = sections
     h
   end
@@ -33,8 +34,14 @@ class Chart < ActiveRecord::Base
     duplicate(:without => "id", :with => { :name => "#{name} (Copy)" })
   end
 
-  def dup!
-    duplicate(:without => "id", :with => { :is_template => false })
+  #
+  # Pass :save => true to persist the new chart
+  # The only way we can hook up ticket types to the dupe is if we save
+  #
+  # So unsaved charts will not have ticket types attached
+  #
+  def dup!(options = {})
+    duplicate(options.merge({:without => "id", :with => { :is_template => false }}))
   end
   
   def create_first_section
@@ -67,9 +74,16 @@ class Chart < ActiveRecord::Base
   # params_hash is the params[:chart] with :section_attributes as a key.  
   # This is how they're submitted from the ticket types form
   #
-  def update_attributes_from_params(params_hash = {})
-    upgrade_event
+  def update_attributes_from_params(params_hash = {}, parent_chart = nil)
     update_attributes(params_hash)
+    upgrade_event
+    sync_with_venue(params_hash)
+  end
+
+  def sync_with_venue(params_hash)
+    if self.event
+      self.event.venue.update_default_chart_from(self.event.default_chart)
+    end
   end
   
   #If this is a free event, and they've specified prices on this chart, then upgrade to a paid event
@@ -91,22 +105,19 @@ class Chart < ActiveRecord::Base
     prefix + ', default chart'
   end
 
-  def self.default_chart_for(event)
-    raise TypeError, "Expecting an Event" unless event.kind_of? Event
-    @chart = self.new
-    @chart.name = self.get_default_name(event.name)
-    @chart.event_id = event.id
-    @chart
-  end
-
   def has_paid_sections?
     !self.ticket_types.drop_while{|s| s.price.to_i == 0}.empty?
   end
 
-  private
+  protected
 
+    #
+    # Both AssignedChart and GeneralAdmissionChart implement this method in their subclasses
+    # Both implementations make use of this via super()
+    #
     def duplicate(options = {})
       rejections = Array.wrap(options[:without])
+      rejections << "type"
       additions = options[:with] || {}
       attrs = self.attributes.reject { |key, value| rejections.include?(key) }.merge(additions)
 

data/app/models/database_views/item_view.rb

@@ -27,13 +27,36 @@ class ItemView < ActiveRecord::Base
   default_scope order('created_at desc')
 
   def self.sales_export_filename_for(organization)
-    "exports/Artfully-Ticket-Sales-Export-#{organization.id}.csv"
+    "exports/Artfully-Sales-Export-#{organization.id}.csv"
   end
 
   def self.donations_export_filename_for(organization)
     "exports/Artfully-Donations-Export-#{organization.id}.csv"
   end
 
+  #load {item_id => product_type_name} once to avoid 3n query call for each item
+  def self.product_type_name(item_id, organization_id)
+    if @hash.nil?
+      sql = "SELECT items.id,  " +
+        "CASE WHEN items.product_type = 'Ticket' THEN ticket_types.name " +
+        "WHEN items.product_type = 'Membership' THEN membership_types.name " +
+        "WHEN items.product_type = 'Pass' THEN pass_types.name " +
+        "END AS product_type_name " +
+        "FROM items " +
+        "LEFT OUTER JOIN orders ON orders.id = items.order_id " +
+        "LEFT OUTER JOIN tickets ON tickets.id = items.product_id AND items.product_type = 'Ticket' " +
+        "LEFT OUTER JOIN memberships ON memberships.id = items.product_id AND items.product_type = 'Membership' " +
+        "LEFT OUTER JOIN passes ON passes.id = items.product_id AND items.product_type = 'Pass' " +
+        "LEFT OUTER JOIN ticket_types ON ticket_types.id = tickets.ticket_type_id " +
+        "LEFT OUTER JOIN membership_types ON membership_types.id = memberships.membership_type_id " +
+        "LEFT OUTER JOIN pass_types ON pass_types.id = passes.pass_type_id " +
+        "WHERE product_type IN('Ticket', 'Pass', 'Membership') AND orders.organization_id = #{organization_id}"
+      @hash  = Hash[ActiveRecord::Base.connection.select_all(sql).map(&:values)]
+    end
+    @hash[item_id]
+  end
+
+
   comma :donation do
     created_at_local_to_organization("Date")
 
@@ -42,8 +65,7 @@ class ItemView < ActiveRecord::Base
     nongift_amount("Non-Deductible Amount")   { |cents| ((cents || 0) / 100.00) }
     special_instructions("Special Instructions")
     notes("Notes")
-
-    order("Creator")          { |order| order.creator && order.creator.email }
+    creator("Creator")
 
     person("Email")           { |person| person.email }
     person("Salutation")      { |person| person.salutation }
@@ -91,10 +113,10 @@ class ItemView < ActiveRecord::Base
     datetime_local_to_organization("Performance Date-Time")
     payment_method("Payment Method")
     price("Ticket Price") { |cents| number_to_currency(cents.to_f/100) }
+    item("Ticket Type") { |item| item.product.ticket_type && item.product.ticket_type.name  }
     special_instructions("Special Instructions")
     notes("Notes")
-
-    order("Creator")          { |order| order.creator && order.creator.email }
+    creator("Creator")
 
     person("Email")           { |person| person.email }
     person("Salutation")      { |person| person.salutation }
@@ -228,4 +250,53 @@ class ItemView < ActiveRecord::Base
     person("Do Not Email")    { |person| person.do_not_email }
     person("Do Not Call")     { |person| person.do_not_call }
   end
+
+  comma :all_sales do
+    created_at_local_to_organization("Date of Purchase")
+    order_id("Order Id")
+    product_type("Item")
+    item_id("Detail") { |item_id| ItemView.product_type_name(item_id, self.instance_variable_get("@instance").organization_id)  }
+    payment_method("Payment Method")
+    price("Price") { |cents| number_to_currency(cents.to_f/100) }
+    special_instructions("Special Instructions")
+    notes("Notes")
+    creator("Creator")
+
+    person("Email")           { |person| person.email }
+    person("Salutation")      { |person| person.salutation }
+    person("First Name")      { |person| person.first_name }
+    person("Middle Name")     { |person| person.middle_name }
+    person("Last Name")       { |person| person.last_name }
+    person("Suffix")          { |person| person.suffix }
+    person("Nickname")        { |person| person.nickname }
+    person("Listing Name")    { |person| person.listing_name }
+    person("Title")           { |person| person.title }
+    person("Type")            { |person| person.type }
+    person("Subtype")         { |person| person.subtype }
+    person("Company Name")    { |person| person.company_name }
+
+    ('A'..'C').each_with_index do |letter, i|
+      person("Address#{letter} Type")        { |person| person.addresses[i] && person.addresses[i].kind }
+      person("Address#{letter} Address 1")   { |person| person.addresses[i] && person.addresses[i].address1 }
+      person("Address#{letter} Address 2")   { |person| person.addresses[i] && person.addresses[i].address2 }
+      person("Address#{letter} City")        { |person| person.addresses[i] && person.addresses[i].city }
+      person("Address#{letter} State")       { |person| person.addresses[i] && person.addresses[i].state }
+      person("Address#{letter} Zip")         { |person| person.addresses[i] && person.addresses[i].zip }
+      person("Address#{letter} Country")     { |person| person.addresses[i] && person.addresses[i].country }
+    end
+
+    (1..3).each do |i|
+      person("Phone#{i} type")          { |person| person.phones[i-1] && person.phones[i-1].kind }
+      person("Phone#{i} number")        { |person| person.phones[i-1] && person.phones[i-1].number }
+    end
+
+    person("Website")         { |person| person.website }
+    person("Twitter Handle")  { |person| person.twitter_handle }
+    person("Facebook URL")    { |person| person.facebook_url }
+    person("Linked In Url")   { |person| person.linked_in_url }
+    person("Tags")            { |person| person.tags.join("|") }
+    person("Do Not Email")    { |person| person.do_not_email }
+    person("Do Not Call")     { |person| person.do_not_call }
+    person("Household Name")  { |person| person.household && person.household.name }
+  end
 end

data/app/models/discount.rb

@@ -57,6 +57,10 @@ class Discount < ActiveRecord::Base
     end
   end
 
+  def calculate_discount_for(ticket_type)
+    self.ticket_types.include?(ticket_type.name) ? type.calculate_discounted_price(ticket_type.price) : ticket_type.price
+  end
+
   def ensure_properties_are_set
     type.validate
   end

data/app/models/discounts/buy_one_get_one_free_discount_type.rb

@@ -8,7 +8,7 @@ class BuyOneGetOneFreeDiscountType < DiscountType
     every_other_ticket.each do |ticket|
       ticket.update_column(:cart_price, 0)
     end
-    FeeCalculator.apply(FeeStrategy.new).to(@discount.cart)
+    @discount.cart.calculate_fees(@discount.cart)
   end
 
   def every_other_ticket

data/app/models/discounts/dollars_off_tickets_discount_type.rb

@@ -13,7 +13,11 @@ class DollarsOffTicketsDiscountType < DiscountType
         ticket.update_column(:cart_price, 0)
       end
     end
-    FeeCalculator.apply(FeeStrategy.new).to(@discount.cart)
+    @discount.cart.calculate_fees(@discount.cart)
+  end
+
+  def calculate_discounted_price(price_in_cents)
+    price_in_cents - @properties[:amount]
   end
 
   def self.fee

data/app/models/discounts/percentage_off_tickets_discount_type.rb

@@ -17,9 +17,13 @@ class PercentageOffTicketsDiscountType < DiscountType
     "#{@properties[:percentage] * 100.00}% off each ticket"
   end
 
-private
-
-  def ensure_percentage_exists
-    raise "Percentage missing!" if @properties[:percentage].blank?
+  def calculate_discounted_price(price_in_cents)
+    price_in_cents - (price_in_cents * @properties[:percentage])
   end
+
+  private
+
+    def ensure_percentage_exists
+      raise "Percentage missing!" if @properties[:percentage].blank?
+    end
 end

data/app/models/event.rb

@@ -5,13 +5,17 @@ class Event < ActiveRecord::Base
   include Ticket::Reporting
   include EventPresenter
   include OhNoes::Destroy
+  include ActionView::Helpers::TextHelper
   require 'email_validator'
 
   CATEGORIES = ["Dance", "Film & Electronic Media", "Literary Arts", "Music", "Theater", "Visual Arts", "Other"]
   
   attr_accessible :name, :producer, :description, :contact_email, :contact_phone, :image, :venue_attributes,
                   :show_special_instructions, :special_instructions_caption, :public, :primary_category,
-                  :secondary_categories, :primary_category_other, :secondary_category_other, :members_only, :subtitle
+                  :secondary_categories, :primary_category_other, :secondary_category_other, :members_only,
+                  :subtitle, :assigned
+  
+  attr_accessor :reserved_seating
 
   store :cached_stats, :accessors => [ :on_sale, :off_sale, :sold, :sales_total ]
 
@@ -49,6 +53,7 @@ class Event < ActiveRecord::Base
   before_create :set_primary_category
   before_create { self.public = true }
   after_create :create_default_chart
+  after_create :create_venue_chart
 
   serialize :secondary_categories, Array
 
@@ -143,23 +148,38 @@ class Event < ActiveRecord::Base
     Item.where(:show_id => self.shows)
   end
 
-  def filter_charts(charts)
-    charts.reject { |chart| already_has_chart(chart) }
-  end
-
   def set_primary_category
     self.primary_category ||= "Other"
   end
   
   def create_default_chart
-    chart = self.charts.build({ :name => self.name, 
-                                :is_template => false })
-    chart.organization = self.organization
+    unless default_chart
+      chart = chart_class.default_chart_for(self)
+      self.charts << chart
+      chart.save
+    end
+    chart
+  end
+
+  #
+  # In the case where producer is re-using chart from a venue
+  # This will return false if a default_chart has been set
+  # No changes will be made if a default chart has been set
+  #
+  def set_default_chart(chart)
+    return false unless default_chart.nil?    
+    self.charts << chart
+    chart.event = self
     chart.save
   end
 
+  def chart_class
+    self.assigned? ? AssignedChart : GeneralAdmissionChart
+  end
+
   def default_chart
-    charts.first
+    return nil unless self.persisted?
+    self.charts.includes(chart_class.included_models).first
   end
 
   def upcoming_shows_rel
@@ -200,17 +220,56 @@ class Event < ActiveRecord::Base
     upcoming_shows(:all, true).select(&:published?)
   end
 
-  def next_show
+  #
+  # Used to build a flimsy show for use by the Rails form on shows/new
+  #
+  def build_next_show
     shows.build(:datetime => Show.next_datetime(shows.last))
     show = shows.pop
-    show.chart = default_chart.dup!
+    show.chart = default_chart.dup!({:save => false})
     show
   end
 
   def as_widget_json(options = {})
-    as_json(options.merge({:methods => ['venue', 'uuid'], :except => [:members_only, :cached_stats]})).merge('performances' => upcoming_public_shows.as_json)
+    as_json(options.merge({:methods => ['venue', 'uuid'], :except => [:members_only, :cached_stats, :assigned]})).merge('performances' => upcoming_public_shows.as_json)
   end
 
+  EVENT_CALENDAR_COLORS = ["#3a87ad", "#16a085", "#27ae60", "#8e44ad", "#2c3e50", "#d35400", "#c0392b"]
+  #
+  # This drives the all events calendar for producers
+  #
+  def self.as_full_calendar_json(organization, starts_at=nil, ends_at=nil)
+    shows_rel = organization.shows.includes(:event => :venue)
+    shows_rel = shows_rel.where('datetime > ?', starts_at) unless starts_at.nil?
+    shows_rel = shows_rel.where('datetime < ?', ends_at) unless ends_at.nil?
+
+    shows=shows_rel.all
+
+    #
+    # Reject shows which have had their events deleted
+    #
+    shows.reject! {|s| s.event.nil?}
+
+    event_ids = shows.collect(&:event_id).uniq
+    event_ids.sort!
+    colors = EVENT_CALENDAR_COLORS
+
+    shows.collect do |show|
+      { :title  => show.event.name.truncate(30),
+        :start  => show.datetime_local_to_event,
+        :allDay => false,
+        :id     => show.id,
+        :state  => show.state,
+        :event_id => show.event_id,
+        :backgroundColor => show.published? ? colors[(event_ids.index(show.event_id) % colors.length)] : "#adadad",
+        :borderColor => colors[(event_ids.index(show.event_id) % colors.length)]
+      }
+    end
+  end
+
+  #
+  # This drivers the per-event show calendar for producers
+  #
   def as_full_calendar_json
     shows.includes(:event).collect do |p|
       { :title  => '',
@@ -223,6 +282,17 @@ class Event < ActiveRecord::Base
     end
   end
 
+  def as_storefront_calendar_json
+    upcoming_public_shows.collect do |p|
+      { :title      => '',
+        :start      => p.datetime_local_to_event,
+        :allDay     => false,
+        :uuid       => p.uuid,
+        :color      => p.sold_out? ? "#ADADAD" : "#33AADD"
+      }
+    end
+  end
+
   def as_json(options = {})
     super(options)
   end
@@ -264,4 +334,8 @@ class Event < ActiveRecord::Base
     def already_has_chart(chart)
       !self.charts.select{|c| c.name == chart.name }.empty?
     end
+
+    def create_venue_chart
+      self.venue.update_default_chart_from(self.default_chart)
+    end
 end

data/app/models/general_admission_chart.rb

@@ -0,0 +1,51 @@
+class GeneralAdmissionChart < Chart 
+  def self.default_chart_for(chartable)
+    chart = GeneralAdmissionChart.where(chartable.class.name.foreign_key.to_sym => chartable.id)
+                         .where(:is_template => true)
+                         .first
+    return chart unless chart.nil?
+
+    chart = GeneralAdmissionChart.new
+    chart.name = chartable.name
+    chart.organization = chartable.organization
+    chart.send("#{chartable.class.name.downcase}=", chartable)
+    chart.is_template = true
+    chart
+  end
+
+  def duplicate(options = {})
+    new_chart = super(options)
+    
+    if (!!options[:save])
+      new_chart.save
+    end
+
+    new_chart
+  end
+
+  #
+  # Suitable for chaining includes
+  # :chart => chart.class.included_models
+  #
+  def self.included_models
+    [:sections => :ticket_types]
+  end
+
+  def create_tickets
+    raise "Only charts that have been assigned to shows can create tickets" if self.show.nil?
+    Ticket.create_many(self.show, self.sections.first, self.sections.first.capacity)
+    self.sections.first.put_on_sale(self.sections.first.capacity)
+  end
+
+  #
+  # Returns an array of available tickets as well as an error
+  # [[ ticket array ], "error message suitable for end-user display"]
+  #
+  def get_available_tickets(ticket_type, ticket_limit = 4, member = nil, seat = nil, cart = nil)
+    available_tickets = Ticket.available({:section_id     => ticket_type.section.id,
+                      :ticket_type_id => nil }, 
+                      [ticket_limit, ticket_type.available(member)].min)
+  
+    [available_tickets, ""]
+  end
+end