artfully_ose 1.0.0.rc4 → 1.1.0.rc1

data/app/mailers/producer_mailer.rb

@@ -1,5 +1,5 @@
 class ProducerMailer < ActionMailer::Base
-  default :from => "support@artful.ly"
+  default :from => ARTFULLY_CONFIG[:contact_email]
   layout "mail"
 
   def donation_kit_notification(kit, producer)
@@ -35,4 +35,12 @@ class ProducerMailer < ActionMailer::Base
 
     mail :to => @producer.email, :subject => "Artful.ly: Ticket Offer Rejected"
   end
+
+  def mailchimp_kit_initial_sync_notification(kit, producer, list_name)
+    @kit = kit
+    @list_name = list_name
+    @organization = kit.organization
+
+    mail :to => producer.email, :subject => "Artful.ly: MailChimp kit synced"
+  end
 end

data/app/mailers/reports_mailer.rb

@@ -0,0 +1,12 @@
+class ReportsMailer < ActionMailer::Base
+  default :from => ARTFULLY_CONFIG[:contact_email]
+  layout "mail"
+  add_template_helper(ApplicationHelper)
+  add_template_helper(ArtfullyOseHelper)
+
+  def daily(tix, donations)
+    @tix = tix
+    @donations = donations
+    mail to: @tix.organization.owner.email, subject: "Daily Report for #{@tix.date.to_s(:long)}"
+  end
+end

data/app/models/action.rb

@@ -1,18 +1,21 @@
 class Action < ActiveRecord::Base
+  include OhNoes::Destroy
+  
   belongs_to :person
   belongs_to :creator, :class_name => "User", :foreign_key => "creator_id"
   belongs_to :organization
   belongs_to :subject, :polymorphic => true
+  belongs_to :import
 
   validates_presence_of :occurred_at
   validates_presence_of :person_id
 
   set_watch_for :occurred_at, :local_to => :organization
+
   #
   # Action types: give, go, do, get, join, hear
   #
-
-  GIVE_TYPES = [ "Donation (Cash)", "Donation (Check)", "Donation (In-Kind)" ].freeze
+  GIVE_TYPES = [ "Monetary", "In-Kind" ].freeze
 
   def self.create_of_type(type)
     case type
@@ -67,11 +70,34 @@ class Action < ActiveRecord::Base
       "Press" ]
   end
   
+  #This returnes an ARel, so you can chain
   def self.recent(organization, limit = 5)
-    Action.includes(:person).where(:organization_id => organization).order('created_at DESC').limit(limit)
+    Action.includes(:person).where(:organization_id => organization).order('occurred_at DESC').limit(limit)
   end
 
   def give_action_subtypes
     GIVE_TYPES
   end
+
+  #
+  # This exists solely so that DJ can serialize an unsaved action so that ActionJob can run
+  # There's nothing inherent to Action in this method so it looks like a good candidate to 
+  # move into a Module.  But, I'm not thrilled with it and don't want it used willy-nilly
+  # Perhaps in an DelayedJob::Unsaved::Serializable Module or something. 
+  #
+  def to_open_struct
+    action_struct = OpenStruct.new
+    self.class.column_names.each do |col|
+      action_struct.send("#{col}=", self.send(col))
+    end
+    action_struct
+  end
+
+  def self.from_open_struct(action_struct)
+    action = Kernel.const_get(action_struct.type).new
+    Kernel.const_get(action_struct.type).column_names.each do |col|
+      action.send("#{col}=", action_struct.send(col)) unless action_struct.send(col).nil?
+    end
+    action    
+  end
 end

data/app/models/actions/get_action.rb

@@ -1,4 +1,8 @@
 class GetAction < Action
+  def subtype
+    "Purchase"
+  end
+
   def action_type
     "Get"
   end

data/app/models/actions/go_action.rb

@@ -2,4 +2,22 @@ class GoAction < Action
   def action_type
     "Go"
   end
+  
+  def verb
+    "attended"
+  end
+  
+  def self.for(show, person, occurred_at=nil)
+    GoAction.new.tap do |go_action|
+      go_action.person = person
+      go_action.subject = show
+      go_action.details = "attended #{show.event}"
+      go_action.organization = show.organization
+      go_action.occurred_at = ( occurred_at.nil? ? show.datetime : occurred_at )
+    end
+  end
+  
+  def sentence
+    details
+  end
 end

data/app/models/actions/refund_action.rb

@@ -0,0 +1,14 @@
+class RefundAction < GetAction
+  
+  def subtype
+    "Refund"
+  end
+
+  def action_type
+    "Get"
+  end
+  
+  def verb
+    ""
+  end
+end

data/app/models/address.rb

@@ -1,5 +1,5 @@
 class Address < ActiveRecord::Base
-  attr_accessible :address1, :address2, :city, :state, :zip, :country
+  attr_accessible :address1, :address2, :city, :state, :zip, :country, :person_id
   belongs_to :person
 
   validates :person_id, :presence => true
@@ -22,20 +22,7 @@ class Address < ActiveRecord::Base
   end
 
   def self.from_payment(payment)
-    if payment.respond_to? "billing_address"
-      billing_address = payment.billing_address
-
-      new({
-        :address1 => billing_address.street_address1,
-        :address2 => billing_address.street_address2,
-        :city     => billing_address.city,
-        :state    => billing_address.state,
-        :zip      => billing_address.postal_code,
-        :country  => billing_address.country
-      })
-    else
-      nil
-    end
+    payment.try(:customer).try(:address)
   end
   
   def self.unhash(address)
@@ -57,9 +44,12 @@ class Address < ActiveRecord::Base
       
       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         => "address updated#{extra}, old address was: (#{old_addr})" })
+          :text         => text 
+        })
         note.user = user
       else
         return false

data/app/models/adjustments.rb

@@ -0,0 +1,10 @@
+module Adjustments
+  def service_fee_per_item(itmz)
+    #ternery operation solely to avoid dividing by zero
+    number_of_non_free_items(itmz) == 0 ? 0 : (order.service_fee || 0) / number_of_non_free_items(itmz)
+  end
+
+  def number_of_non_free_items(itmz)
+    itmz.reject{|item| item.original_price == 0}.size
+  end
+end

data/app/models/box_office.rb

@@ -15,7 +15,7 @@ module BoxOffice
   end
   
   class Order < ::Order  
-    def location
+    def self.location
       "Box office"
     end
   end

data/app/models/carts/cart.rb

@@ -3,15 +3,17 @@ class Cart < ActiveRecord::Base
   
   has_many :donations, :dependent => :destroy
   has_many :tickets, :after_add => :set_timeout
-  after_destroy :release_tickets
+  after_destroy :clear!
   attr_accessor :special_instructions
 
+  belongs_to :discount
+
   state_machine do
     state :started
     state :approved
     state :rejected
 
-    event(:approve) { transitions :from => [ :started, :rejected ], :to => :approved }
+    event(:approve, :success => :record_sold_price) { transitions :from => [ :started, :rejected ], :to => :approved }
     event(:reject)  { transitions :from => [ :started, :rejected ], :to => :rejected }
   end
 
@@ -25,6 +27,7 @@ class Cart < ActiveRecord::Base
   end
 
   def clear!
+    reset_prices_on_tickets
     clear_tickets
     clear_donations
   end
@@ -39,7 +42,7 @@ class Cart < ActiveRecord::Base
   end
 
   def release_tickets
-    tickets.each { |ticket| ticket.update_attribute(:cart, nil) }
+    tickets.each { |ticket| ticket.remove_from_cart }
   end
 
   def set_timeout(ticket)
@@ -51,6 +54,7 @@ class Cart < ActiveRecord::Base
   end
 
   def expire_ticket(ticket)
+    ticket.reset_price!
     tickets.delete(ticket)
   end
 
@@ -76,10 +80,22 @@ class Cart < ActiveRecord::Base
     self.tickets << tkts
   end
 
-  def total
+  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
@@ -93,15 +109,14 @@ class Cart < ActiveRecord::Base
 
     #TODO: Move the requires_authorization? check into the payments classes.  Cart shouldn't care
     if payment.requires_authorization?
+      options[:service_fee] = fee_in_cents
       pay_with_authorization(payment, options)
     else
       approve!
     end
   end
 
-  def finish(person, order_timestamp)
-    metric_sale_total
-    tickets.each { |ticket| ticket.sell_to(person, order_timestamp) }
+  def finish
   end
 
   def generate_donations
@@ -134,27 +149,23 @@ class Cart < ActiveRecord::Base
     reseller == nil
   end
 
+  def reset_prices_on_tickets
+    transaction do
+      tickets.each {|ticket| ticket.reset_price! }
+    end
+  end
+
   private
 
-    def pay_with_authorization(payment, options)
-      response = payment.purchase(options)
-      response.success? ? approve! : reject!
+    def record_sold_price
+      self.tickets.each do |ticket|
+        ticket.sold_price = ticket.cart_price || ticket.price
+        ticket.save
+      end
     end
 
-    def metric_sale_total
-      bracket =
-        case self.total
-        when 0                  then "$0.00"
-        when (1 ... 1000)       then "$0.01 - $9.99"
-        when (1000 ... 2000)    then "$10 - $19.99"
-        when (2000 ... 5000)    then "$20 - $49.99"
-        when (5000 ... 10000)   then "$50 - $99.99"
-        when (10000 ... 25000)  then "$100 - $249.99"
-        when (25000 ... 50000)  then "$250 - $499.99"
-        else                         "$500 or more"
-        end
-
-      RestfulMetrics::Client.add_compound_metric(ENV["RESTFUL_METRICS_APP"], "sale_complete", [ bracket ])
+    def pay_with_authorization(payment, options)
+      payment.purchase(options) ? approve! : reject!
     end
 
 end

data/app/models/chart.rb

@@ -1,23 +1,29 @@
 class Chart < ActiveRecord::Base
   include Ticket::Foundry
   foundry :using => :sections, :with => lambda { { :venue => event.venue.name } }
-
-  attr_accessible :name, :is_template, :event_id, :organization_id, :old_mongo_id, :sections_attributes, :organization, :event
+  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
 
   belongs_to :event
   belongs_to :organization
   has_one :show
   has_many :sections, :order => 'price DESC'
   accepts_nested_attributes_for :sections, :reject_if => lambda { |a| a[:capacity].blank? }, :allow_destroy => true
-  after_create :create_first_section
+  
+  after_create :create_first_section, :unless => lambda { @skip_create_first_section == true }
 
   validates :name, :presence => true, :length => { :maximum => 255 }
+  scope :template, where(:is_template => true)
 
   def as_json(options = {})
-    super({:methods => ['sections']}.merge(options))
+    h = super(options)
+    h[:sections]   = sections.storefront
+    h
+  end
+  
+  def widget_sections
+    self.sections.storefront.all
   end
-
-  scope :template, where(:is_template => true)
 
   # copy! is when they're editing charts and want to create a copy of
   # this chart to modify further (weekday and weekend charts)
@@ -47,8 +53,10 @@ class Chart < ActiveRecord::Base
     # 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[:sections_attributes].each do |index, section_hash|
+    #  
+    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
     end

data/app/models/checkout.rb

@@ -1,6 +1,7 @@
 class Checkout
   include ActiveSupport::Callbacks
   define_callbacks :payment
+  define_callbacks :order
   
   include Ext::Callbacks::Checkout
   
@@ -10,6 +11,19 @@ class Checkout
   def self.for(cart, payment)
     cart.checkout_class.new(cart, payment)
   end
+  
+  def message
+    message = @payment.errors.full_messages.to_sentence.downcase
+    message = message.gsub('customer', 'contact info')
+    message = message.gsub('credit card is', 'payment details are')
+    message = message[0].upcase + message[1..message.length] unless message.blank? #capitalize first word
+    
+    if message.blank?
+      message = "We had a problem validating your payment.  Wait a few moments and try again or contact us to complete your purchase."
+    end
+    
+    message
+  end
 
   def initialize(cart, payment)
     @cart = cart
@@ -32,33 +46,42 @@ class Checkout
   end
 
   def finish
-    @person = Person.find_or_create(@customer, cart.organizations.first)
-    @person.update_address(Address.from_payment(payment), cart.organizations.first.time_zone, nil, "checkout")
-
     run_callbacks :payment do
-      cart.pay_with(@payment)
+      pay
     end
     
-    ::Rails.logger.debug("Payment made, cart is approved: [#{cart.approved?}]")
-    
     if cart.approved?
       order_timestamp = Time.now
-      create_order(order_timestamp)
-      cart.finish(@person, order_timestamp)
-    end
       
+      run_callbacks :order do
+        @created_orders = create_order(order_timestamp)
+      end
+      
+      cart.finish
+    end
+    
     cart.approved?
   end
+  
+  def pay
+    @cart.pay_with(@payment)
+    @cart.approved?
+  end
 
   private
     def create_sub_orders(order_timestamp)
       created_orders = []
       cart.organizations.each do |organization|
+        @person = Person.find_or_create(@customer, organization)
+        @person.update_address(Address.from_payment(payment), organization.time_zone, nil, "checkout")
+        @person.add_phone_if_missing(payment.payment_phone_number)
+        
         @order = new_order(organization, order_timestamp, @person)
         @order.save!
         OrderMailer.confirmation_for(order).deliver unless @person.dummy? || @person.email.blank?
         created_orders << @order
       end
+      
       created_orders
     end