artfully_ose 1.2.0.beta.1 → 1.2.0.pre

data/app/models/exchange.rb

@@ -1,7 +1,7 @@
 class Exchange
   include ActiveModel::Validations
 
-  attr_accessor :order, :items, :tickets, :ticket_type, :send_email_confirmation
+  attr_accessor :order, :items, :tickets, :ticket_type
   attr_reader :exchange_order
 
   validates_presence_of :order  
@@ -17,12 +17,11 @@ class Exchange
   #The original order
   #The items to exchange
   #The tickets that they are being exchanged for
-  def initialize(order, items, tickets, ticket_type, send_email_confirmation = false)
+  def initialize(order, items, tickets = [], ticket_type)
     self.order        = order
     self.items        = items
-    self.tickets      = tickets || []
-    self.ticket_type  = ticket_type
-    self.send_email_confirmation = send_email_confirmation
+    self.tickets      = tickets
+    self.ticket_type = ticket_type
   end
 
   def items_are_exchangeable
@@ -43,7 +42,7 @@ class Exchange
 
   def submit
     ActiveRecord::Base.transaction do
-      self.tickets = Ticket.lock(self.tickets, self.ticket_type, Cart.create)
+      self.tickets = Ticket.lock(tickets, ticket_type, Cart.create)
       sell_new_items
       return_old_items
     end
@@ -76,7 +75,6 @@ class Exchange
       exchange_order.created_at = time
       exchange_order.for_organization order.organization
       exchange_order.details = "Order is the result of an exchange on #{I18n.l time, :format => :slashed_date}"
-      exchange_order.skip_email = !send_email_confirmation
       exchange_order << tickets
     end
     exchange_order.record_exchange! items

data/app/models/{ext.rb → ext/ext.rb}

@@ -26,7 +26,7 @@ module Ext
     
     def set_uuid
       if self.uuid.nil?
-        self.uuid = PREFIX + SecureRandom.uuid
+        self.uuid = SecureRandom.uuid
       end
     end
     
@@ -34,17 +34,4 @@ module Ext
       PREFIX + SecureRandom.uuid
     end
   end
-
-  module S3Link
-    def download_link_for(field)
-      s3 = AWS::S3.new(
-          :access_key_id     => ENV['S3_ACCESS_KEY_ID'],
-          :secret_access_key => ENV['S3_SECRET_ACCESS_KEY']
-      )
-      bucket = s3.buckets[ENV['S3_BUCKET']]
-      object = bucket.objects[self.send(field).path]
-      url    = object.url_for(:read, :expires => 10*60)
-      url.to_s
-    end
-  end
 end

data/app/models/ext/integrations.rb

@@ -2,18 +2,11 @@ module Ext
   module Integrations
     module Member
     end
-
-    module ServiceFee
-      SERVICE_FEE = 0
-    end
-
+    
     module User
-      def need_more_info?
-        false
-      end
     end
-
-    module Kit
+    
+    module Kit      
       def record_activation
       end
 
@@ -23,41 +16,37 @@ module Ext
 
     module Show
       def record_publish
-      end      
+      end
 
-      #
-      # Used for rendering widget and api charts. Storefront uses section.ticket_types_for instead
-      #
       def chart_for(channel, organization_id = nil)
         chart = Chart.joins(:show)
                      .joins(:sections => :ticket_types)
                      .includes(:sections => :ticket_types)
                      .where('shows.id = ?', self.id)
                      .where("ticket_types.#{channel} = ?", true)
-
+       
         chart.first
       end
     end
-
+    
     module Organization
       def self.included(base)
         base.class_eval do
           after_create do
-            [TicketingKit,RegularDonationKit,MembershipKit,PassesKit].each do |klass|
+            [TicketingKit,RegularDonationKit].each do |klass|
               kit = klass.new
               kit.state = 'activated'
               kit.organization = self
               kit.save
             end
           end
-          validates_presence_of :name, :email, :time_zone
         end
       end
-
+      
       def connected?
         false
-      end
-
+      end 
+      
       def fsp
         nil
       end
@@ -80,37 +69,37 @@ module Ext
       def name_for_donations
         self.name
       end
-
+      
       def update_kits
       end
 
       def sponsored_kit
         nil
       end
-
+      
       def shows_with_sales
         raise "Just use shows"
       end
     end
-
+    
     module Order
       def self.included(base)
         base.extend ClassMethods
       end
-
+      
       def fa_id
         nil
       end
-
+      
       module ClassMethods
-        def sale_search(search)
+        def sale_search(search)        
           standard = ::Order.includes(:items => { :show => :event })
 
-          if search.start
+          if search.start   
             standard = standard.after(search.start)
           end
 
-          if search.stop
+          if search.stop   
             standard = standard.before(search.stop)
           end
 
@@ -126,7 +115,7 @@ module Ext
 
           standard.all
         end
-      end
+      end     
     end
 
     module Ticket
@@ -139,24 +128,17 @@ module Ext
       def record_comp
       end
     end
-
+    
     module Event
       def shows_with_sales(seller)
         raise "Just use shows"
       end
     end
-
+    
     module Item
       def settlement_issued?
         false
       end
     end
-
-    module ArtfullyOseController
-      def need_more_info?
-        current_user.try(:need_more_info?)
-      end
-      private :need_more_info?
-    end
   end
 end

data/app/models/fee_strategy.rb

@@ -1,51 +1,5 @@
 class FeeStrategy
-  def ticket_fee
-    ARTFULLY_CONFIG[:ticket_fee] || 0
-  end
-
   def apply_to_cart(cart)
-    return if cart.is_a? BoxOffice::Cart
-
-    handle_tickets(cart)
-    handle_memberships(cart)
-    handle_passes(cart)
-  end
-
-  def handle_tickets(cart)
-    cart.tickets.each do |ticket|
-      if ticket.price > 0
-        ticket.service_fee = ticket_fee
-      elsif ticket.price == 0
-        ticket.service_fee = 0
-      end
-
-      if ticket.cart_price == 0 && waive_fee_for?(ticket)
-        ticket.service_fee = 0
-      end
-
-      ticket.save
-    end
-  end
-
-  def handle_memberships(cart)
-    cart.memberships.each do |membership|
-      membership.service_fee = membership.membership_type.hide_fee? ? 0 : (membership.cart_price || membership.price) * MembershipType::SERVICE_FEE
-      membership.save
-    end
-  end
-
-  def handle_passes(cart)
-    cart.passes.each do |pass|
-      pass.service_fee = pass.pass_type.hide_fee? ? 0 : pass.price * PassType::SERVICE_FEE
-      pass.save
-    end
-  end
-
-  def waive_fee_for?(ticket)
-    # 
-    # This match is too tightly coupled to discount. Also, horrible.
-    # Check needs to be made because cart_price == 0 && BOGO means fee is applied
-    #
-    (ticket.discount.try(:promotion_type) == "DollarsOffTickets") || ticket.pass.present?
+    #noop
   end
 end

data/app/models/import.rb

@@ -73,9 +73,9 @@ class Import < ActiveRecord::Base
   #
   # This composes errors thrown *during* the import.  For validation errors, see invalidate!
   #
-  def fail!(error, row = nil, row_num = 0)
+  def fail!(error = nil, row = nil, row_num = 0)
     Rails.logger.error "IMPORT ERROR [#{self.id}]: #{error.message}"
-    error.backtrace.each { |line| Rails.logger.error "     #{line}" } if error.backtrace 
+    error.backtrace.each { |line| Rails.logger.error "     #{line}" }
     self.import_errors.create! :row_data => row, :error_message => "Row #{row_num}: #{error.message}"
     failed!
     rollback
@@ -170,26 +170,6 @@ class Import < ActiveRecord::Base
     person
   end
 
-  def create_person(parsed_row)
-    if !attach_person(parsed_row).naming_details_available?
-      person = self.organization.dummy
-    elsif !parsed_row.email.blank?
-      person = Person.first_or_create({:email => parsed_row.email, :organization => self.organization}.merge(parsed_row.person_attributes), {}) do |p|
-        p.import = self
-      end
-      person.update_from_import(attach_person(parsed_row))
-      person.skip_commit = true
-      person.save
-    else    
-      person = attach_person(parsed_row)
-      if !person.save
-        self.reload
-        fail!(RowError.new(person.errors.full_messages.join(", ")), parsed_row.row)
-      end 
-    end
-    person  
-  end
-
   class RowError < ArgumentError
   end
   

data/app/models/imports/donations_import.rb

@@ -48,9 +48,27 @@ class DonationsImport < Import
     validate_amounts(parsed_row)
     true
   end
+  
+  def create_person(parsed_row)
+    Rails.logger.info("Import #{id} DONATION_IMPORT: Creating person")
+    if !parsed_row.email.blank?
+      person = Person.first_or_create({:email => parsed_row.email, :organization => self.organization}.merge(parsed_row.person_attributes), {}) do |p|
+        p.import = self
+      end
+    else    
+      person = attach_person(parsed_row)
+      if !person.save
+        Rails.logger.info("Import #{id} DONATION_IMPORT: Person save failed")
+        self.import_errors.create! :row_data => parsed_row.row, :error_message => person.errors.full_messages.join(", ")
+        self.reload
+        fail!
+      end 
+    end
+    person  
+  end
    
   def create_contribution(parsed_row, person)
-    Rails.logger.info("Processing Import [#{id}] DONATION_IMPORT: Creating contribution")
+    Rails.logger.info("Import #{id} DONATION_IMPORT: Creating contribution")
     validate_amounts(parsed_row)
     amount              = parsed_row.amount
     deductible_amount   = parsed_row.unparsed_deductible_amount.blank?  ? amount - parsed_row.nongift_amount     : parsed_row.deductible_amount

data/app/models/imports/events_import.rb

@@ -16,11 +16,6 @@ class EventsImport < Import
     order       = create_order(parsed_row, person, event, show, ticket)
     actions     = create_actions(parsed_row, person, event, show, order)
   end
-
-  def imported!
-    @imported_shows.values.each {|show| show.delay.refresh_stats}
-    super
-  end
   
   def rollback_events
     Event.where(:import_id => self.id).all.each {|e| e.destroy}
@@ -33,7 +28,7 @@ class EventsImport < Import
   end
   
   def row_valid?(parsed_row)
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Validating Row")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Validating Row")
     raise Import::RowError, "No Event Name included in this row: #{parsed_row.row}" unless parsed_row.event_name 
     raise Import::RowError, "No Show Date included in this row: #{parsed_row.row}" unless parsed_row.show_date
     raise Import::RowError, "Please include a payment method in this row: #{parsed_row.row}" if parsed_row.payment_method.blank?
@@ -43,35 +38,53 @@ class EventsImport < Import
     true
   end
   
+  def create_person(parsed_row)
+    if !attach_person(parsed_row).naming_details_available?
+      person = self.organization.dummy
+    elsif !parsed_row.email.blank?
+      person = Person.first_or_create({:email => parsed_row.email, :organization => self.organization}.merge(parsed_row.person_attributes), {}) do |p|
+        p.import = self
+      end
+    else    
+      person = attach_person(parsed_row)
+      if !person.save
+        self.import_errors.create! :row_data => parsed_row.row, :error_message => person.errors.full_messages.join(", ")
+        self.reload
+        fail!
+      end 
+    end
+    person  
+  end
+  
   def create_chart(parsed_row, event, show)
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Creating chart")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Creating chart")
     chart = show.chart || show.create_chart({ :name => event.name, :skip_create_first_section => true })   
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Using chart:")
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: #{chart.inspect}")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Using chart:")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: #{chart.inspect}")
     amount = parsed_row.amount || 0
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Amount is [#{amount}]")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Amount is [#{amount}]")
     section = chart.sections.first || chart.sections.build(:name => event.name, :capacity => 1)
     section.skip_create_first_ticket_type = true
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Using section:")
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: #{section.inspect}")
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Bumping section capacity")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Using section:")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: #{section.inspect}")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Bumping section capacity")
     section.capacity = section.capacity + 1 unless section.new_record?
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Saving section")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Saving section")
     section.save
     ticket_type = section.ticket_types.where(:price => amount).first || section.ticket_types.create({:name => event.name, :price => amount, :limit => 0})
     ticket_type.limit = ticket_type.limit + 1
     ticket_type.save    
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: #{section.inspect}")
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Saving chart")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: #{section.inspect}")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Saving chart")
     chart.save
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: #{show.inspect}")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: #{show.inspect}")
     saved = show.save(:validate => false)
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Show saved[#{saved}]")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Show saved[#{saved}]")
     chart
   end
 
   def create_event(parsed_row, person)
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Creating event")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Creating event")
     event = Event.where(:name => parsed_row.event_name).where(:organization_id => self.organization).first
     return event if event
       
@@ -85,9 +98,9 @@ class EventsImport < Import
     event.contact_email = self.organization.email || self.user.email
     event.import = self
     event.save!
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Created event #{event.inspect}")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Created event #{event.inspect}")
     unless event.charts.empty?
-      Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Default event chart created #{event.charts.first.inspect}") 
+      Rails.logger.info("Import #{id} EVENT_IMPORT: Default event chart created #{event.charts.first.inspect}") 
     end
     event
   end
@@ -97,7 +110,7 @@ class EventsImport < Import
   end
   
   def existing_show(show_date, event_name)
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Checking existing show")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Checking existing show")
     @imported_shows ||= {}
     show = @imported_shows[show_key(show_date, event_name)]    
   end
@@ -113,67 +126,61 @@ class EventsImport < Import
   end
   
   def new_show(parsed_row, event)
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Creating new show")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Creating new show")
     show = Show.new
     show.datetime = time_zone_parser.parse(eight_pm?(parsed_row.show_date))
     show.event = event
     show.organization = self.organization
     show.state = "unpublished"                      #Hacky end-around state machine here because we don't have a chart yet
     show.save(:validate => false)
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Show saved #{show.inspect}")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Show saved #{show.inspect}")
     
     @imported_shows[show_key(parsed_row.show_date, event.name)] = show
     show    
   end
   
   def create_show(parsed_row, event)
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Creating show")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Creating show")
     return existing_show(parsed_row.show_date, event) || new_show(parsed_row, event)
   end
   
   def create_actions(parsed_row, person, event, show, order)
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Creating actions")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Creating actions")
     go_action = GoAction.for(show, person) do |go_action|
       go_action.import = self
       go_action.save
     end
      
+    #get action is created by the order
     get_action = GetAction.where(:subject_id => order.id).first
-    if get_action
-      get_action.details = order.ticket_details
-      get_action.occurred_at = time_zone_parser.parse(parsed_row.order_date) unless parsed_row.order_date.blank?
-      get_action.save
-    else
-      order.create_purchase_action
-    end
-    get_action ||= GetAction.where(:subject_id => order.id).first
-
+    get_action.update_attribute(:occurred_at, time_zone_parser.parse(parsed_row.order_date)) unless parsed_row.order_date.blank?
+    
     return go_action, get_action
   end
   
   def create_ticket(parsed_row, person, event, show, chart)
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Creating ticket")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Creating ticket")
     amount = parsed_row.amount || 0
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Amount is [#{amount}]")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Amount is [#{amount}]")
     section = chart.sections.first
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Section is [#{section.inspect}]")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Section is [#{section.inspect}]")
     ticket_type = section.ticket_types.where(:price => amount).first
     
     raise Import::RuntimeError, 'No section found for ticket' unless section
     
     ticket = Ticket.build_one(show, section,1, true)
     ticket.ticket_type = ticket_type
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Ticket built [#{ticket.inspect}]")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Ticket built [#{ticket.inspect}]")
     ticket.sell_to person
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Ticket sold to [#{person.inspect}]")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Ticket sold to [#{person.inspect}]")
     ticket.sold_price = amount
     ticket.save
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Ticket saved [#{ticket.inspect}]")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Ticket saved [#{ticket.inspect}]")
     ticket
   end
    
   def create_order(parsed_row, person, event, show, ticket)
-    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Creating order")
+    Rails.logger.info("Import #{id} EVENT_IMPORT: Creating order")
     order_key = [show.id.to_s,person.id.to_s,parsed_row.payment_method].join('-')
     @imported_orders ||= {}
     order = @imported_orders[order_key] || ImportedOrder.new
@@ -188,7 +195,8 @@ class EventsImport < Import
     order.skip_actions = true
     order.save
     order.update_attribute(:created_at, time_zone_parser.parse(parsed_row.order_date)) unless parsed_row.order_date.blank?
-  
+    order.create_purchase_action
+    order.actions.where(:type => "GetAction").first.update_attribute(:occurred_at, parsed_row.order_date) unless parsed_row.order_date.blank?
     @imported_orders[order_key] = order
     order
   end