artfully_ose 1.1.0 → 1.2.0.alpha.1

data/app/models/actions/hear_action.rb

@@ -2,8 +2,20 @@ class HearAction < Action
   def action_type
     "Hear"
   end
-  
+
+  def verb
+    "heard"
+  end
+
   def sentence
-    "contacted you"
+    " heard from you"
+  end
+  
+  def quip
+    "heard from us (via #{subtype.downcase})"
+  end
+
+  def self.subtypes
+    ["Email", "Phone", "Postal", "Meeting", "Twitter", "Facebook", "Blog", "Press"]
   end
 end

data/app/models/actions/join_action.rb

@@ -2,4 +2,8 @@ class JoinAction < Action
   def action_type
     "Join"
   end
+
+  def self.subtypes
+    []
+  end
 end

data/app/models/actions/refund_action.rb

@@ -1,5 +1,6 @@
 class RefundAction < GetAction
-  
+  include ImmutableAction
+
   def subtype
     "Refund"
   end

data/app/models/actions/say_action.rb

@@ -0,0 +1,23 @@
+class SayAction < Action
+  def action_type
+    "Say"
+  end
+
+  def verb
+    "said"
+  end
+
+  def sentence
+    " contacted you"
+  end
+
+  def quip
+    result  = "said"
+    result += " (via #{subtype.downcase})" if subtype.present?
+    result
+  end
+
+  def self.subtypes
+    ["Email", "Phone", "Postal", "Meeting", "Twitter", "Facebook", "Blog", "Press"]
+  end
+end

data/app/models/address.rb

@@ -1,17 +1,30 @@
 class Address < ActiveRecord::Base
-  attr_accessible :address1, :address2, :city, :state, :zip, :country, :person_id
+
+  attr_accessible :address1, :address2, :city, :state, :zip, :country, :person_id, :household_id
+
   belongs_to :person
+  belongs_to :household
 
-  validates :person_id, :presence => true
+  #
+  # Needed because widget checkouts don't yet have a person_id
+  #
+  def valid_for_widget_checkout?
+    !(address1.blank? || city.blank? || state.blank? || zip.blank?)
+  end
 
   def address
     "#{address1} #{address2}"
   end
-  
+
   def to_s
     "#{address1} #{address2} #{city} #{state} #{zip} #{country}"
   end
 
+  # Country intentionally omitted
+  def blank?
+    address1.blank? && address2.blank? && city.blank? && state.blank? && zip.blank?
+  end
+
   def is_same_as(addr)
     return address1.eql?(addr.address1) &&
            address2.eql?(addr.address2) &&
@@ -24,9 +37,9 @@ class Address < ActiveRecord::Base
   def self.from_payment(payment)
     payment.try(:customer).try(:address)
   end
-  
+
   def self.unhash(address)
-    (address.is_a? Hash) ? Address.new(address)  : address
+    (address.is_a? Hash) ? Address.new(address.except(:id, :created_at, :updated_at, :old_mongo_id))  : address
   end
 
   def self.find_or_create(pers_id)
@@ -41,21 +54,38 @@ class Address < ActiveRecord::Base
       ["address1", "address2", "city", "state", "zip", "country"].each do |field|
         self.send("#{field}=", address.send(field))
       end
-      
-      if save 
+
+      if save
         extra = updated_by.nil? ? "" : " from #{updated_by}"
         text = "address updated#{extra}"
         text = text + ", old address was: (#{old_addr})" unless old_addr.blank?
         note = person.notes.create({
           :occurred_at  => DateTime.now.in_time_zone(time_zone),
-          :text         => text 
+          :text         => text
         })
         note.user = user
       else
         return false
-      end      
+      end
     end
 
     true
   end
+
+  def ==(other)
+    address1 == other.address1 && address2 == other.address2  && city == other.city  && state == other.state  && zip == other.zip  && country == other.country
+  end
+
+  def values_hash
+    {
+      :address1 => address1,
+      :address2 => address2,
+      :city => city,
+      :state => state,
+      :zip => zip,
+      :country => country
+    }
+  end
+
+
 end

data/app/models/cart.rb

@@ -0,0 +1,254 @@
+class Cart < ActiveRecord::Base
+  include ActiveRecord::Transitions
+  
+  has_many :donations, :dependent => :destroy
+  has_many :tickets,      :after_add => :calculate_fees
+  has_many :memberships,  :after_add => :calculate_fees
+  has_many :passes,       :after_add => :calculate_fees
+  after_destroy :clear!
+  before_validation :set_token
+  attr_accessor :special_instructions
+  attr_accessible :token, :reseller_id
+
+  validates :token,
+            :presence => true,
+            :length => { :is => 64 },
+            :format => /\A[0-9a-f]+\z/i
+
+  belongs_to :discount
+
+  #
+  # Named .applied_pass to avoid confusion with passes that are being purchased
+  # This is the pass that has been applied to the cart for discounted tickets
+  #
+  belongs_to :applied_pass, :class_name => Pass
+
+  state_machine do
+    state :started
+    state :approved
+    state :rejected
+
+    event(:approve, :success => :record_sold_price) { transitions :from => [ :started, :rejected ], :to => :approved }
+    event(:reject)  { transitions :from => [ :started, :rejected ], :to => :rejected }
+  end
+
+  delegate :empty?, :to => :items
+
+  #
+  # Note that this does return Item objects. It returns Tickets, Donations, Memberships, etc...
+  #
+  # TODO: Refactor this to another name to avoid confusion with Item
+  #
+  def items
+    self.tickets + self.donations + self.memberships + self.passes
+  end
+    
+  def checkout_class
+    Checkout
+  end
+
+  def has_discount_or_pass?
+    !discount.nil? || !applied_pass.nil?
+  end
+
+  def applied_code
+    discount.try(:code) || applied_pass.try(:pass_code)
+  end
+
+  def clear!
+    clear_tickets
+    clear_donations
+    clear_memberships
+    clear_passes
+    self.discount = nil
+    self.applied_pass = nil
+    save
+  end
+  
+  def clear_tickets
+    Ticket.unlock(self.tickets, self)
+    self.tickets = []
+  end
+
+  def can_hold?(ticket)
+    true
+  end
+
+  def clear_donations
+    temp = []
+
+    #This won't work if there is more than 1 FAFS donation on the order
+    donations.each do |donation|
+      temp = donations.delete(donations)
+    end
+    temp
+  end
+
+  def clear_memberships
+    self.memberships.destroy_all
+  end
+
+  def clear_passes
+    self.passes.destroy_all
+  end
+  
+  def as_json(options = {})
+    super({ :methods => [ 'tickets', 'donations', 'memberships' ]}.merge(options))
+  end
+
+  def fee_in_cents
+    items.sum(&:service_fee)
+  end
+
+  def calculate_fees(obj)
+    FeeCalculator.apply(FeeStrategy.new).to(self)
+  end
+
+  def <<(tkts)
+    tkts = Array.wrap(tkts)
+    tkts.each do |t|
+      raise "Cannot add tickets to a cart without a ticket type set on the Ticket" if t.ticket_type.nil?
+      t.cart_price  = t.ticket_type.price
+    end
+    self.tickets << tkts.flatten
+  end
+
+  def subtotal
+    items.sum(&:price)
+  end
+
+  def total_before_discount
+    items.sum(&:price) + fee_in_cents
+  end
+
+  def total
+    items.sum(&:cart_price) + fee_in_cents
+  end
+
+  def discount_amount
+    total_before_discount - total
+  end
+
+  def unfinished?
+    started? or rejected?
+  end
+
+  def completed?
+    approved?
+  end
+
+  def generate_donations
+    organizations.collect do |organization|
+      if organization.can?(:receive, Donation)
+        donation = Donation.new
+        donation.organization = organization
+        donation
+      end
+    end.compact
+  end
+
+  def organizations
+    ids = []
+    [:donations, :memberships, :tickets, :passes].each do |collection|
+      ids = ids + self.send(collection).collect(&:organization_id)
+    end
+    ids = ids.uniq
+    Organization.find(ids)
+  end
+
+  def self.create_for_reseller(reseller_id = nil, params = {})
+    reseller_id.blank? ? Cart.create(params) : Reseller::Cart.create( params.merge({:reseller => Organization.find(reseller_id)}) )
+  end
+  
+  def self.find_or_create(cart_token, reseller_id)
+    if cart_token.nil?
+      raise ActiveRecord::RecordNotFound.new("No cart with nil token")
+    end
+
+    if reseller_id.present?
+      if Cart.find_by_token_and_reseller_id(cart_token, reseller_id)
+        cart = Cart.find_by_token_and_reseller_id(cart_token, reseller_id)
+      else
+        cart = Reseller::Cart.create(token: cart_token, reseller_id: reseller_id)
+      end
+    else
+      cart = Cart.find_or_create_by_token!(cart_token)
+    end
+
+    if cart.completed?
+      cart.transfer_token_to_new_cart
+    else
+      cart
+    end
+  end
+
+  def transfer_token_to_new_cart
+    new_cart = Cart.new
+    transaction do
+      new_cart.type = self.type
+      new_cart.reseller_id = self.reseller_id
+      new_cart.token = self.token
+      self.token = nil
+      self.save!
+      new_cart.save!
+    end
+    new_cart
+  end
+
+  def reseller_is?(reseller_id)
+    (self.reseller_id.blank? && reseller_id.blank?) || (self.reseller_id == reseller_id.to_i)
+  end
+
+  def prepare_for_pass!
+    transaction do
+      tickets.each {|ticket| ticket.prepare_for_pass! }
+    end
+  end
+
+  def prepare_for_discount!
+    transaction do
+      tickets.each {|ticket| ticket.prepare_for_discount! }
+    end
+  end
+
+  def reset_prices_on_tickets
+    transaction do
+      tickets.each {|ticket| ticket.reset_price! }
+    end
+  end
+
+  #
+  # for_reseller is deprecated and will be removed when Widget v1 support is removed. Please use find_or_create.
+  #
+  def self.for_reseller(reseller_id = nil, params = {})
+    ActiveSupport::Deprecation.warn("for_reseller is deprecated and will be removed when Widget v1 support is removed. Please use find_or_create.")
+    reseller_id.blank? ? Cart.create(params) : Reseller::Cart.create( params.merge({:reseller => Organization.find(reseller_id)}) )
+  end
+
+  #
+  # find_cart is deprecated and will be removed when Widget v1 support is removed. Please use find_or_create.  
+  #
+  def self.find_cart(cart_id, reseller_id)
+    ActiveSupport::Deprecation.warn("find_cart is deprecated and will be removed when Widget v1 support is removed. Please use find_or_create.")
+    Rails.logger.debug("Searching for cart [#{cart_id}] for reseller [#{reseller_id}]")
+    rel = where(:id => cart_id)
+    rel.where(:reseller_id => reseller_id) unless reseller_id.blank?
+    rel.first
+  end
+
+  private
+
+    #
+    # Might not need this anymore. Investigate when sold_price is set
+    #
+    def record_sold_price
+      self.tickets.each do |ticket|
+        ticket.sold_price = ticket.cart_price
+        ticket.save
+      end
+    end
+
+    def set_token
+      self.token ||= SecureRandom.hex(32)
+    end
+end

data/app/models/chart.rb

@@ -2,12 +2,13 @@ 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, :old_mongo_id, :sections_attributes, :organization, :event, :skip_create_first_section
+  attr_accessible :name, :is_template, :event_id, :organization_id, :old_mongo_id, :sections_attributes, :ticket_types_attributes, :organization, :event, :skip_create_first_section
 
   belongs_to :event
   belongs_to :organization
   has_one :show
-  has_many :sections, :order => 'price DESC'
+  has_many :sections, :order => 'name DESC'
+  has_many :ticket_types, :through => :sections, :order => 'ticket_types.price DESC'
   accepts_nested_attributes_for :sections, :reject_if => lambda { |a| a[:capacity].blank? }, :allow_destroy => true
   
   after_create :create_first_section, :unless => lambda { @skip_create_first_section == true }
@@ -17,7 +18,7 @@ class Chart < ActiveRecord::Base
 
   def as_json(options = {})
     h = super(options)
-    h[:sections]   = sections.storefront
+    h[:sections]   = sections
     h
   end
   
@@ -38,29 +39,35 @@ class Chart < ActiveRecord::Base
   
   def create_first_section
     if sections.empty?
-      self.sections.build({ :name => "General Admission", 
-                            :price => 0, 
+      self.sections.build({ :name => "General Admission",
                             :capacity => 0 }).save
     end
   end
-  
+
   #
-  # params_hash is the params[:chart] with :section_attributes as a key.  
-  # This is how they're submitted from the ticket types form
+  # Any pre-processing of the chart_params (like manipulating the price) can be done here
   #
-  def update_attributes_from_params(params_hash)
+  def self.polish_params(params_hash = {})
     #
     # HACK: The move to bootstrap left us with currency submission in the form os "DD.CC" which 
     # Artfully interpreted as DD.00.  
     # This hack converts DD.CC to DDCC
     #  
-    params_hash ||= {}
-
-    params_hash.fetch(:sections_attributes, []).each do |index, section_hash|
-      new_price = Section.price_to_cents(section_hash['price'])
-      section_hash['price'] = new_price
+    params_hash.fetch(:sections_attributes, []).each do |index,section_hash|
+      section_hash.fetch(:ticket_types_attributes, []).each do |index, ticket_type_hash|
+        new_price = TicketType.price_to_cents(ticket_type_hash['price'])
+        ticket_type_hash['price'] = new_price
+      end
     end
-    
+
+    params_hash
+  end
+  
+  #
+  # 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 = {})
     update_attributes(params_hash)
     upgrade_event
   end
@@ -93,19 +100,19 @@ class Chart < ActiveRecord::Base
   end
 
   def has_paid_sections?
-    !self.sections.drop_while{|s| s.price.to_i == 0}.empty?
+    !self.ticket_types.drop_while{|s| s.price.to_i == 0}.empty?
   end
 
   private
 
-  def duplicate(options = {})
-    rejections = Array.wrap(options[:without])
-    additions = options[:with] || {}
-    attrs = self.attributes.reject { |key, value| rejections.include?(key) }.merge(additions)
+    def duplicate(options = {})
+      rejections = Array.wrap(options[:without])
+      additions = options[:with] || {}
+      attrs = self.attributes.reject { |key, value| rejections.include?(key) }.merge(additions)
 
-    self.class.new(attrs).tap do |copy|
-      copy.sections = self.sections.collect { |section| section.dup! }
+      self.class.new(attrs).tap do |copy|
+        copy.sections = self.sections.collect { |section| section.dup! }
+      end
     end
-  end
 
 end