artfully_ose 1.1.0 → 1.2.0.alpha.1

data/app/models/ext/preprocessor.rb

@@ -0,0 +1,7 @@
+module Ext
+  module Preprocessor
+    def preprocess
+      true
+    end
+  end
+end

data/app/models/extendable.rb

@@ -0,0 +1,6 @@
+module Extendable
+  def adjust_expiration_to(new_ends_at)
+    self.ends_at = new_ends_at
+    self.save
+  end
+end

data/app/models/fee_calculator.rb

@@ -0,0 +1,13 @@
+class FeeCalculator
+  attr_accessor :fee_strategy
+
+  def self.apply(fee_strategy)
+    fc = FeeCalculator.new
+    fc.fee_strategy = fee_strategy
+    fc
+  end
+
+  def to(cart)
+    self.fee_strategy.apply_to_cart(cart)
+  end
+end

data/app/models/fee_strategy.rb

@@ -0,0 +1,5 @@
+class FeeStrategy
+  def apply_to_cart(cart)
+    #noop
+  end
+end

data/app/models/gateway_transaction.rb

@@ -32,7 +32,9 @@ class GatewayTransaction < ActiveRecord::Base
   end
 
   def clean
-    unless self.response.params.nil? || self.response.params.fetch("braintree_transaction",{}).fetch("credit_card_details", {}).fetch("masked_number", nil).nil?
+    unless (self.response.params.nil? || 
+            self.response.params["braintree_transaction"].nil? || 
+            self.response.params.fetch("braintree_transaction",{}).fetch("credit_card_details", {}).fetch("masked_number", nil).nil?)
       self.response.params["braintree_transaction"]["credit_card_details"]["masked_number"] = nil
       self.response.params["braintree_transaction"]["credit_card_details"]["bin"] = nil
     end

data/app/models/household.rb

@@ -0,0 +1,61 @@
+class Household < ActiveRecord::Base
+
+  attr_accessible :name, :address_attributes, :overwrite_member_addresses
+
+  has_one :address
+  has_many :individuals, :class_name => "Individual"
+  belongs_to :organization
+
+  accepts_nested_attributes_for :address, :allow_destroy => false
+
+  validates :name, :uniqueness => true
+
+  def lifetime_value
+    individuals.sum(:lifetime_value)
+  end
+
+  def lifetime_ticket_value
+    individuals.sum(:lifetime_ticket_value)
+  end
+
+  def lifetime_donations
+    individuals.sum(:lifetime_donations)
+  end
+
+  def lifetime_ticket_count
+    Ticket.where(:buyer_id => individuals.pluck(:id)).count
+  end
+
+  def lifetime_donations_count
+    individuals.includes(:orders).map { |i| i.orders.map { |o| o.donations.count }.sum }.sum
+  end
+
+  def notes
+    Note.where(:person_id => individuals.pluck(:id))
+  end
+
+  def actions
+    Action.where(:person_id => individuals.pluck(:id))
+  end
+
+  def addresses
+    Address.where(:person_id => individuals.pluck(:id))
+  end
+
+  def tags
+    ActsAsTaggableOn::Tagging.where(:taggable_type => "Person", :taggable_id => individuals.pluck(:id))
+  end
+
+  def update_member_addresses
+    return unless address.present?
+
+    individuals.each do |individual|
+      if individual.address.present?
+        individual.address.update_attributes(address.values_hash)
+      else
+        individual.address = address.dup
+      end
+    end
+  end
+
+end

data/app/models/household_suggester.rb

@@ -0,0 +1,58 @@
+class HouseholdSuggester
+
+  def initialize(org)
+    @org = org
+  end
+
+  def by_address
+    results = []
+    start = Time.now
+    people.each do |person|
+      break if (Time.now - start > 5 || results.count > 14)
+      next if person.address.nil?
+      next if already_found?(results, person)
+
+      a = person.address
+      matches = people.where(:addresses => {:address1 => a.address1, :address2 => a.address2}).where('addresses.zip like ?', a.zip)
+      results << matches.to_a if matches.count > 1
+    end
+
+    suggestions = []
+    results.each do |result|
+      existing = SuggestedHousehold.with_people(result)
+      unless existing.present? && existing.ignored
+        suggestions << SuggestedHousehold.find_or_create_with_people(result)
+      end
+    end
+
+    suggestions
+  end
+
+  def by_spouse
+    suggestions = [].to_set
+    start = Time.now
+    people.each do |person|
+      break if (Time.now - start > 5 || suggestions.count > 14)
+      person.relationships_of_relation("spouse to").each do |rel|
+        existing = SuggestedHousehold.with_people([rel.person, rel.other])
+        unless existing.present? && existing.ignored
+          suggestions << SuggestedHousehold.find_or_create_with_people([rel.person, rel.other])
+        end
+      end
+    end
+
+    suggestions.to_a
+  end
+
+  private
+
+  def already_found?(results, person)
+    results.any? do |matches|
+      matches.include?(person)
+    end
+  end
+
+  def people
+    @org.people.includes(:address).where('people.household_id is null')
+  end
+end

data/app/models/import.rb

@@ -4,6 +4,7 @@ class Import < ActiveRecord::Base
   include Imports::Processing
 
   has_many :import_errors, :dependent => :delete_all
+  has_many :import_messages, :dependent => :delete_all
   has_many :import_rows, :dependent => :delete_all
   has_many :people, :dependent => :destroy
   has_many :actions, :dependent => :destroy
@@ -17,6 +18,10 @@ class Import < ActiveRecord::Base
   DATE_INPUT_FORMAT = "%m/%d/%Y"
   DATE_INPUT_FORMAT_WITH_TIME = "%m/%d/%Y %l:%M%P"
   
+  def message(row_number=nil, parsed_row=nil, person, message_text)
+    self.import_messages.create({:row_number => row_number, :row_data => parsed_row.try(:row), :person => person, :message => message_text})
+  end
+
   def self.build(type)
     case type
     when "events"
@@ -68,7 +73,9 @@ class Import < ActiveRecord::Base
   #
   # This composes errors thrown *during* the import.  For validation errors, see invalidate!
   #
-  def fail!(error = nil, row = nil, row_num = 0)
+  def fail!(error, 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 
     self.import_errors.create! :row_data => row, :error_message => "Row #{row_num}: #{error.message}"
     failed!
     rollback
@@ -80,7 +87,11 @@ class Import < ActiveRecord::Base
   
   def rollback
   end
-  
+
+  def recallable?
+    false
+  end
+
   def parsed_rows
     return @parsed_rows if @parsed_rows
     @parsed_rows = []
@@ -118,7 +129,7 @@ class Import < ActiveRecord::Base
 
     self.pending!
     
-  #TODO: Needs to be re-worked to include the row humber in the error
+  #TODO: Needs to be re-worked to include the row number in the error
   rescue CSV::MalformedCSVError => e
     error_message = "There was an error while parsing the CSV document: #{e.message}"
     self.import_errors.create!(:error_message => error_message)
@@ -131,24 +142,26 @@ class Import < ActiveRecord::Base
     self.invalidate!
   end
 
+  def hash_address(parsed_row)
+    parsed_row.address_attributes
+  end
+
   def attach_person(parsed_row)
-    ip = parsed_row
-    
     person = self.people.build(parsed_row.person_attributes)
     person.organization = self.organization
-    person.address = Address.new \
-      :address1  => ip.address1,
-      :address2  => ip.address2,
-      :city      => ip.city,
-      :state     => ip.state,
-      :zip       => ip.zip,
-      :country   => ip.country
 
-    person.tag_list = ip.tags_list.join(", ")
+    if person.subtype.downcase =~ /business|foundation|government|nonprofit|other/
+      person.type = "Company"
+    else
+      person.type = "Individual"
+    end
+
+    person.build_address(hash_address(parsed_row))
+    person.tag_list = parsed_row.tags_list.join(", ")
 
     1.upto(3) do |n|
-      kind = ip.send("phone#{n}_type")
-      number = ip.send("phone#{n}_number")
+      kind = parsed_row.send("phone#{n}_type")
+      number = parsed_row.send("phone#{n}_number")
       if kind.present? && number.present?
         person.phones << Phone.new(kind: kind, number: number)
       end
@@ -157,6 +170,26 @@ 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/import_message.rb

@@ -0,0 +1,6 @@
+class ImportMessage < ActiveRecord::Base
+  include OhNoes::Destroy
+  belongs_to :import 
+  belongs_to :person
+  attr_accessible :import_id, :message, :row_number, :row_data, :person
+end

data/app/models/imports/donations_import.rb

@@ -36,9 +36,9 @@ class DonationsImport < Import
   
   def row_valid?(parsed_row)
     raise Import::RowError, "No Amount included in this row: #{parsed_row.row}" if parsed_row.unparsed_amount.blank?
-    raise Import::RowError, "Please include a first name, last name, or email in this row: #{parsed_row.row}" unless attach_person(parsed_row).person_info
+    raise Import::RowError, "Please include a first name, last name, email, or company name in this row: #{parsed_row.row}" unless attach_person(parsed_row).naming_details_available?
     raise Import::RowError, "Please include a payment method in this row: #{parsed_row.row}" if parsed_row.payment_method.blank?
-    raise Import::RowError, "Donation type must be 'Monetary' or 'In-Kind': #{parsed_row.row}" unless Action::GIVE_TYPES.include? (parsed_row.donation_type)
+    raise Import::RowError, "Donation type must be 'Monetary' or 'In-Kind': #{parsed_row.row}" unless GiveAction.subtypes.include? (parsed_row.donation_type)
     valid_date?   parsed_row.donation_date
     
     [:unparsed_amount, :unparsed_nongift_amount, :unparsed_deductible_amount].each do |amt|
@@ -48,28 +48,9 @@ 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(parsed_row.email, self.organization, 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
-    puts person.inspect
-    person  
-  end
    
   def create_contribution(parsed_row, person)
-    Rails.logger.info("Import #{id} DONATION_IMPORT: Creating contribution")
+    Rails.logger.info("Processing 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,6 +16,11 @@ 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}
@@ -28,7 +33,7 @@ class EventsImport < Import
   end
   
   def row_valid?(parsed_row)
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Validating Row")
+    Rails.logger.info("Processing 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?
@@ -38,49 +43,35 @@ class EventsImport < Import
     true
   end
   
-  def create_person(parsed_row)
-    if !attach_person(parsed_row).person_info
-      person = self.organization.dummy
-    elsif !parsed_row.email.blank?
-      person = Person.first_or_create(parsed_row.email, self.organization, 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("Import #{id} EVENT_IMPORT: Creating chart")
+    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Creating chart")
     chart = show.chart || show.create_chart({ :name => event.name, :skip_create_first_section => true })   
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Using chart:")
-    Rails.logger.info("Import #{id} EVENT_IMPORT: #{chart.inspect}")
+    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Using chart:")
+    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: #{chart.inspect}")
     amount = parsed_row.amount || 0
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Amount is [#{amount}]")
-    section = chart.sections.where(:price => amount).first || chart.sections.build(:name => event.name,:price => amount, :capacity => 1)    
-    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")
+    Rails.logger.info("Processing 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")
     section.capacity = section.capacity + 1 unless section.new_record?
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Saving section")
+    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Saving section")
     section.save
-    Rails.logger.info("Import #{id} EVENT_IMPORT: #{section.inspect}")
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Saving chart")
+    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")
     chart.save
-    Rails.logger.info("Import #{id} EVENT_IMPORT: #{show.inspect}")
+    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: #{show.inspect}")
     saved = show.save(:validate => false)
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Show saved[#{saved}]")
+    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Show saved[#{saved}]")
     chart
   end
 
   def create_event(parsed_row, person)
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Creating event")
+    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Creating event")
     event = Event.where(:name => parsed_row.event_name).where(:organization_id => self.organization).first
     return event if event
       
@@ -94,9 +85,9 @@ class EventsImport < Import
     event.contact_email = self.organization.email || self.user.email
     event.import = self
     event.save!
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Created event #{event.inspect}")
+    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Created event #{event.inspect}")
     unless event.charts.empty?
-      Rails.logger.info("Import #{id} EVENT_IMPORT: Default event chart created #{event.charts.first.inspect}") 
+      Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Default event chart created #{event.charts.first.inspect}") 
     end
     event
   end
@@ -106,7 +97,7 @@ class EventsImport < Import
   end
   
   def existing_show(show_date, event_name)
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Checking existing show")
+    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Checking existing show")
     @imported_shows ||= {}
     show = @imported_shows[show_key(show_date, event_name)]    
   end
@@ -122,58 +113,67 @@ class EventsImport < Import
   end
   
   def new_show(parsed_row, event)
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Creating new show")
+    Rails.logger.info("Processing 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("Import #{id} EVENT_IMPORT: Show saved #{show.inspect}")
+    Rails.logger.info("Processing 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("Import #{id} EVENT_IMPORT: Creating show")
+    Rails.logger.info("Processing 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("Import #{id} EVENT_IMPORT: Creating actions")
-    go_action = GoAction.for(show, person)
-    go_action.import = self
-    go_action.save
+    Rails.logger.info("Processing 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
-    get_action.update_attribute(:occurred_at, time_zone_parser.parse(parsed_row.order_date)) unless parsed_row.order_date.blank?
-    
+    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
+
     return go_action, get_action
   end
   
   def create_ticket(parsed_row, person, event, show, chart)
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Creating ticket")
+    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Creating ticket")
     amount = parsed_row.amount || 0
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Amount is [#{amount}]")
-    section = chart.sections.where(:price => amount).first
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Section is [#{section.inspect}]")
+    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Amount is [#{amount}]")
+    section = chart.sections.first
+    Rails.logger.info("Processing 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, section.price,1, true)
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Ticket built [#{ticket.inspect}]")
+    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}]")
     ticket.sell_to person
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Ticket sold to [#{person.inspect}]")
+    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Ticket sold to [#{person.inspect}]")
     ticket.sold_price = amount
     ticket.save
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Ticket saved [#{ticket.inspect}]")
+    Rails.logger.info("Processing Import [#{id}] EVENT_IMPORT: Ticket saved [#{ticket.inspect}]")
     ticket
   end
    
   def create_order(parsed_row, person, event, show, ticket)
-    Rails.logger.info("Import #{id} EVENT_IMPORT: Creating order")
+    Rails.logger.info("Processing 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,8 +188,7 @@ 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_without_delay
-    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