artfully_ose 1.2.0.beta.1 → 1.2.0.pre

data/app/helpers/link_helper.rb

@@ -3,7 +3,7 @@ module LinkHelper
     "active" if content_for(:_active_section) == section.to_s || content_for(:_active_sub_section) == section.to_s
   end
 
-  def in_section?(section)
+  def in?(section)
     "in" if content_for(:_active_section) == section.to_s || content_for(:_active_sub_section) == section.to_s
   end
 
@@ -25,14 +25,4 @@ module LinkHelper
     end
     content_tag :li, link_to(text, url), :class => (condition && 'active')
   end
-  
-  def calendar_active_link_to(text, link, condition=nil, icon)
-    if condition.nil? and String === link
-      condition = link == request.path
-    end
-
-    content_tag :li, :class => (condition && 'active') do
-      link_to "<i class='fa #{icon} icon-gray'></i> #{text}".html_safe, link
-    end
-  end
-end
+end

data/app/mailers/order_mailer.rb

@@ -1,12 +1,3 @@
-#
-# You can render different mailer views based on the order subclass.
-# Views should be in the form of "confirmation_for_(order_subclass)"
-# For example, RefundOrder will automatically render confirmation_for_refund
-#
-# If no view is found (there isn't one for BoxOffice::Order, for example) then
-# defaults to confirmaiton_for
-#
-
 class OrderMailer < ActionMailer::Base
   layout "mail"
 
@@ -20,24 +11,13 @@ class OrderMailer < ActionMailer::Base
       if order.contact_email.present?
         o[:reply_to] = order.contact_email
       end
-      o[:template_name] = template_name_for(order)
-    end
-
-    if order.pdf.present? && (@order.organization.can? :access, :scannable_tickets)
-      attachments['tickets.pdf'] = attached_pdf(order)
     end
-
+    
     mail(options)
   end
 
 private
 
-  def template_name_for(order)
-    template_suffix = "_" + order.class.name.underscore.underscore.gsub("_order","").gsub("/order","")
-    template_name = "confirmation_for" + template_suffix
-    template_exists?(template_name, ["order_mailer"]) ? template_name : "confirmation_for"
-  end
-
   def from(order)
     if ARTFULLY_CONFIG[:contact_email].present?
       ARTFULLY_CONFIG[:contact_email]
@@ -47,11 +27,4 @@ private
       order.organization.email
     end
   end
-
-  def attached_pdf(order)
-    file = Tempfile.new(['tickets', '.pdf'])
-    order.pdf.copy_to_local_file(:original, file)
-    file.rewind
-    file.read
-  end
 end

data/app/mailers/reports_mailer.rb

@@ -1,13 +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, memberships, passes)
-    @tix          = tix
-    @donations    = donations
-    @memberships  = memberships
-    @passes       = passes
+  def daily(tix, donations)
+    @tix = tix
+    @donations = donations
     mail to: @tix.organization.owner.email, bcc: "developers@fracturedatlas.org", subject: "Daily Report for #{@tix.start_date.strftime("%b %d, %Y")}"
   end
 end

data/app/models/ability.rb

@@ -7,7 +7,6 @@ class Ability
     ticketing_abilities_for(user) if user.is_in_organization?
     paid_ticketing_abilities_for(user) if user.current_organization.can? :access, :paid_ticketing
     person_abilities_for(user) if user.is_in_organization?
-    household_abilities_for(user) if user.is_in_organization?
     order_ablilities_for(user) if user.is_in_organization?
     import_ablilities_for(user) if user.is_in_organization?
     default_abilities_for(user)

data/app/models/action.rb

@@ -1,7 +1,7 @@
 class Action < ActiveRecord::Base
   include OhNoes::Destroy
   
-  belongs_to :person, touch: true
+  belongs_to :person
   belongs_to :creator, :class_name => "User", :foreign_key => "creator_id"
   belongs_to :organization
   belongs_to :subject, :polymorphic => true

data/app/models/actions/go_action.rb

@@ -28,10 +28,9 @@ class GoAction < Action
     return existing_action || GoAction.new.tap do |go_action|
       go_action.person = person
       go_action.subject = show
-      go_action.details = "to #{show.event.name} on #{I18n.l show.parsed_local_datetime, :format => :short}"
+      go_action.details = "to #{show.event.name} on #{I18n.l show.datetime_local_to_event, :format => :short}"
       go_action.organization = show.organization
-      time_zone = show.time_zone
-      go_action.occurred_at = ( occurred_at.nil? ? show.parsed_local_datetime.beginning_of_day : occurred_at )
+      go_action.occurred_at = ( occurred_at.nil? ? show.datetime : occurred_at )
       block.call(go_action) if block.present?
     end
   end

data/app/models/address.rb

@@ -1,21 +1,17 @@
 class Address < ActiveRecord::Base
-
-  attr_accessible :address1, :address2, :city, :state, :zip, :country, :person_id, :household_id
-
+  attr_accessible :address1, :address2, :city, :state, :zip, :country, :person_id
   belongs_to :person
-  belongs_to :household
 
   #
-  # Needed because widget checkouts don't yet have a person_id
+  # Note that any validations here are skipped in person.rb
+  # so that unsaved people can also have unsaved addresses
   #
-  def valid_for_widget_checkout?
-    !(address1.blank? || city.blank? || state.blank? || zip.blank?)
-  end
+  validates :person_id, :presence => true
 
   def address
     "#{address1} #{address2}"
   end
-
+  
   def to_s
     "#{address1} #{address2} #{city} #{state} #{zip} #{country}"
   end
@@ -37,9 +33,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.except(:id, :created_at, :updated_at, :old_mongo_id))  : address
+    (address.is_a? Hash) ? Address.new(address)  : address
   end
 
   def self.find_or_create(pers_id)
@@ -54,38 +50,21 @@ 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 → carts/cart.rb}

@@ -2,9 +2,8 @@ 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
+  has_many :tickets
+  has_many :memberships
   after_destroy :clear!
   before_validation :set_token
   attr_accessor :special_instructions
@@ -17,12 +16,6 @@ class Cart < ActiveRecord::Base
 
   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
@@ -34,34 +27,19 @@ class Cart < ActiveRecord::Base
 
   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
+    self.tickets + self.donations + self.memberships
   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
   
@@ -87,10 +65,6 @@ class Cart < ActiveRecord::Base
   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))
@@ -100,10 +74,6 @@ class Cart < ActiveRecord::Base
     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|
@@ -111,6 +81,7 @@ class Cart < ActiveRecord::Base
       t.cart_price  = t.ticket_type.price
     end
     self.tickets << tkts.flatten
+    FeeCalculator.apply(FeeStrategy.new).to(self)
   end
 
   def subtotal
@@ -137,8 +108,23 @@ class Cart < ActiveRecord::Base
     approved?
   end
 
+  def pay_with(payment, options = {})
+    @payment = payment
+
+    #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
+  end
+
   def generate_donations
-    organizations.collect do |organization|
+    organizations_from_tickets.collect do |organization|
       if organization.can?(:receive, Donation)
         donation = Donation.new
         donation.organization = organization
@@ -148,12 +134,19 @@ class Cart < ActiveRecord::Base
   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)
+    (organizations_from_donations + organizations_from_tickets + organizations_from_memberships).uniq
+  end
+
+  def organizations_from_donations
+    Organization.find(donations.collect(&:organization_id))
+  end
+
+  def organizations_from_memberships
+    Organization.find(memberships.collect(&:organization_id))
+  end
+
+  def organizations_from_tickets
+    Organization.find(tickets.collect(&:organization_id))
   end
 
   def self.create_for_reseller(reseller_id = nil, params = {})
@@ -199,12 +192,6 @@ class Cart < ActiveRecord::Base
     (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! }
@@ -248,6 +235,10 @@ class Cart < ActiveRecord::Base
       end
     end
 
+    def pay_with_authorization(payment, options)
+      payment.purchase(options) ? approve! : reject!
+    end
+
     def set_token
       self.token ||= SecureRandom.hex(32)
     end

data/app/models/carts/cart_finder.rb

@@ -0,0 +1,33 @@
+#
+# This is for use with session-based carts. Token-based carts (V3 widget)
+# can't use these methods
+#
+module CartFinder
+  extend ActiveSupport::Concern
+
+  included do |c|
+    c.helper_method :current_cart
+  end
+
+  def current_cart
+    (!session_cart || session_cart.approved?) ? create_new_cart : session_cart
+  end
+
+  def session_cart
+    @current_cart ||= Cart.find_by_id(session[:cart_id])
+  end
+
+  def create_new_cart
+    @current_cart = Cart.create
+    session[:cart_id] = @current_cart ? @current_cart.id : nil
+    @current_cart
+  end
+
+  #
+  # Use with care. Only assign updated carts (in the case of discounts)
+  # TODO: Enforce that this isn't used to actually switch to another cart object
+  #
+  def current_cart=(cart)
+    @current_cart = cart
+  end
+end

data/app/models/checkout.rb

@@ -2,37 +2,31 @@ class Checkout
   include ActiveSupport::Callbacks
   define_callbacks :payment
   define_callbacks :order
-
+  
   include Ext::Callbacks::Checkout
-  include Ext::Preprocessor
-
-  attr_accessor :cart, :payment, :error, :notes
+  
+  attr_accessor :cart, :payment, :error
   attr_reader :order, :person
 
   def self.for(cart, payment)
     cart.checkout_class.new(cart, payment)
   end
-
+  
   def message
     message = @error || @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?
-      if @fafs_success == true
-        message = "We've processed your donation but could not reserve your tickets. Please check your information and try again or contact us to complete your purchase."
-      else
-        message = "We had a problem validating your payment.  Wait a few moments and try again or contact us to complete your purchase."
-      end
+      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, notes=nil)
+  def initialize(cart, payment)
     @cart = cart
-    @notes = notes
     @payment = payment
     @customer = payment.customer
     @payment.amount = @cart.total
@@ -49,92 +43,57 @@ class Checkout
     unless (!!cart and !!payment and payment.valid?)
       return false
     end
-
+    
     true
   end
 
   def finish
-    log "started"
-    begin
-      log "preprocess"
-      if preprocess && pay
-        ActiveRecord::Base.transaction do
-          log "approving"
-          cart.approve!
-          log "approved"
-          run_callbacks :order do
-            log "creating orders"
-            @created_orders = create_order(Time.now)
-            log "created orders [#{@created_orders.collect(&:id)}]"
-          end
-        end
-      else
-        log "authorization failed"
+    run_callbacks :payment do
+      pay
+    end
+    
+    if cart.approved?
+      order_timestamp = Time.now
+      
+      run_callbacks :order do
+        @created_orders = create_order(order_timestamp)
       end
-    rescue Exception => e
-      log "threw exception"
-      log e
-      log e.backtrace.inspect
-      void_payment if @payment_approved
-      raise e
+      
+      cart.finish
     end
-
-    capture_payment if @payment_approved
-    @payment_approved || false
-  end
-
-  def log(message)
-    Rails.logger.info "CHECKOUT: cart [#{cart.id}] #{message}"
+    
+    cart.approved?
   end
-
+  
   def pay
-    log "authorizing"
-    options = {}
-    options[:service_fee] = cart.fee_in_cents
-    @payment_approved = payment.authorize(options)
-    @transaction_id = payment.transaction_id
-    log "authorized with [#{@transaction_id}]"
-    @payment_approved
-  end
-
-  def capture_payment
-    log "capturing payment [#{@transaction_id}]"
-    payment.capture(@transaction_id, {})
-    log "payment captured"
-  end
-
-  def void_payment
-    log "voiding [#{@transaction_id}]"
-    payment.void(@transaction_id, {})
-    log "payment voided"
-  end
-
-  def checkout_name
-    "checkout"
+    @cart.pay_with(@payment)
+    @cart.approved?
   end
 
   private
     def create_sub_orders(order_timestamp)
       created_orders = []
-      log("creating sub orders")
-      log("Organizations in this cart [#{cart.organizations.collect(&:id)}]")
       cart.organizations.each do |organization|
-        attributes = {}
-        attributes[:id]           = @customer.id unless @customer.id.nil?
-        attributes[:email]        = @customer.email
-        attributes[:first_name]   = @customer.first_name
-        attributes[:last_name]    = @customer.last_name
-        attributes[:organization] = organization
-
-        @person = Person.first_or_create(attributes)
-        CheckoutProcessor.process(@person, @customer, Address.from_payment(payment), payment.payment_phone_number, organization.time_zone, checkout_name)
+        @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)
-        log(@order.save!)
-        log("Created order [#{@order.id}]")
+        @order.save!
+
+        #
+        # This should be DJ'd
+        #
+        begin
+          OrderMailer.confirmation_for(order).deliver unless @person.dummy? || @person.email.blank?
+        rescue Exception => e
+          Exceptional.context(:order_id => order.id)
+          Exceptional.handle(e, "Could not send order confirmation for order")
+        end
 
         created_orders << @order
       end
-
+      
       created_orders
     end
 
@@ -152,16 +111,13 @@ class Checkout
         order.created_at                  = order_timestamp
         order.person                      = @person
         order.transaction_id              = @payment.transaction_id
-        order.check_number                = @payment.check_number if payment.kind_of?(CheckPayment)
         order.special_instructions        = @cart.special_instructions
         order.payment_method              = @payment.payment_method
         order.per_item_processing_charge  = @payment.per_item_processing_charge
-        order.notes                       = @notes
 
         order << @cart.tickets.select { |ticket| ticket.organization_id == organization.id }
         order << @cart.donations
         order << @cart.memberships
-        order << @cart.passes
       end
     end
 end