artfully_ose 1.2.0.beta.1 → 1.2.0.pre

data/app/models/payments/cash_payment.rb

@@ -3,9 +3,7 @@ class CashPayment < Payment
   attr_accessor :amount
 
   def initialize(params = {})
-    self.customer       ||= Person.new
-    build_customer_from(params)
-    build_address_from(params)
+    self.customer = params[:customer]
   end
 
   def requires_authorization?

data/app/models/payments/comp_payment.rb

@@ -9,9 +9,7 @@ class CompPayment < Payment
   def initialize(params)
     params = params.is_a?(Array) ? params[0] : params
     self.benefactor = params[:benefactor]
-    self.customer   ||= Person.new
-    build_customer_from(params)
-    build_address_from(params)
+    self.customer = params[:customer]
   end
 
   def requires_authorization?

data/app/models/payments/credit_card_payment.rb

@@ -17,7 +17,10 @@ class CreditCardPayment < ::Payment
   def payment_phone_number
     self.customer.phones.first.try(:number)
   end
-
+  
+  #
+  # We may be able to get some milage out of a repo called active_attr: https://github.com/cgriego/active_attr
+  #
   def build(params)
     [:amount, :user_agreement, :transaction_id].each do |field| 
       self.instance_variable_set("@#{field.to_s}", params[field])
@@ -30,18 +33,25 @@ class CreditCardPayment < ::Payment
     end
     
     unless params[:customer].nil?
-      build_customer_from(params)
-      build_address_from(params)
+      self.customer.first_name  = params[:customer][:first_name]
+      self.customer.last_name   = params[:customer][:last_name]
+      self.customer.email       = params[:customer][:email]
+      
+      self.customer.phones      << Phone.new(:number => params[:customer][:phone]) unless params[:customer][:phone].blank?
+      
+      self.customer.address = Address.new(:address1 => params[:customer][:address][:address1],
+                                          :city     => params[:customer][:address][:city],
+                                          :state    => params[:customer][:address][:state],
+                                          :zip      => params[:customer][:address][:zip])
     end
   end
   
   def gateway
     @gateway ||= ActiveMerchant::Billing::BraintreeGateway.new(
-      :merchant_account_id => Rails.configuration.braintree.merchant_account_id,
-      :merchant_id         => Rails.configuration.braintree.merchant_id,
-      :public_key          => Rails.configuration.braintree.public_key,
-      :private_key         => Rails.configuration.braintree.private_key
-    )
+        :merchant_id => Rails.configuration.braintree.merchant_id,
+        :public_key  => Rails.configuration.braintree.public_key,
+        :private_key => Rails.configuration.braintree.private_key
+      )
   end
   
   def requires_authorization?
@@ -88,47 +98,16 @@ class CreditCardPayment < ::Payment
   end
   
   def authorize(options={})
-    if requires_authorization?
-      response = gateway.authorize(self.amount, credit_card, options.except(:service_fee))
-      record_gateway_transaction(options[:service_fee], self.amount, response)
-      self.transaction_id = response.authorization
-      response.success?
-    else
-      true
-    end
-    rescue Errno::ECONNREFUSED => e
-      ::Rails.logger.error "Connection to processor refused"
-      self.errors.add(:base, "We had a problem processing the sale, please check all your information and try again.")
-      false
-    rescue Exception => e
-      ::Rails.logger.error "Could not contact processor"
-      ::Rails.logger.error e
-      ::Rails.logger.error e.backtrace
-      self.errors.add(:base, "We had a problem processing the sale, please check all your information and try again.")
-      false
+    response = gateway.authorize(self.amount, credit_card, options)
+    self.transaction_id = response.authorization
+    response.authorization
   end
   
-  def capture(transaction_id, options={})
-    if requires_authorization?
-      response = gateway.capture(self.amount, transaction_id, options)
-      record_gateway_transaction(options[:service_fee], self.amount, response)
-      response.success?
-    else
-      true
-    end
+  def capture(authorization, options={})
+    gateway.capture(self.amount, authorization, options)
   end
   alias :settle :capture
 
-  def void(transaction_id, options={})
-    if !transaction_id.blank?
-      response = gateway.void(transaction_id, options)
-      record_gateway_transaction(0, 0, response)
-      response.success?
-    else
-      true
-    end
-  end
-
   #
   # This can't be delayed_job'd because DJ can't deserialize ARs that haven't been persisted
   #

data/app/models/{payment.rb → payments/payment.rb}

@@ -53,39 +53,11 @@ class Payment
       raise "No payment method registered for [#{type}], did you call payment_method in the subclass?"
     end
   end
-
-  def build_customer_from(params)
-    self.customer.first_name  = params.fetch(:customer, {}).fetch(:first_name, "")
-    self.customer.last_name   = params.fetch(:customer, {}).fetch(:last_name, "")
-    self.customer.email       = params.fetch(:customer, {}).fetch(:email, "")
-    
-    self.customer.phones      << Phone.new(:number => params.fetch(:customer, {}).fetch(:phone, "")) unless params[:customer].blank? || params[:customer][:phone].blank?
-  end
-
-  def build_address_from(params)
-    unless params.fetch(:customer, {}).fetch(:address, {}).blank?
-      self.customer.address = Address.new(:address1 => params[:customer][:address][:address1],
-                                          :city     => params[:customer][:address][:city],
-                                          :state    => params[:customer][:address][:state],
-                                          :zip      => params[:customer][:address][:zip])
-    end
-  end
   
   #
-  # Subclasses that need to actually process something should override these methods
+  # Subclasses that need to actually process something should override this method
   #
   def purchase(options = {})
-    true
-  end
-  
-  def authorize(options = {})
-    true
-  end
-  
-  def capture(transaction_id, options = {})
-  end
-  
-  def void(transaction_id, options = {})
   end
 
   #

data/app/models/person.rb

@@ -4,25 +4,18 @@ class Person < ActiveRecord::Base
   include Valuation::LifetimeValue
   include Valuation::LifetimeTicketValue
   include Valuation::LifetimeDonations
-  include Valuation::LifetimeMemberships
-
-  handle_asynchronously :calculate_lifetime_memberships
   handle_asynchronously :calculate_lifetime_donations
   handle_asynchronously :calculate_lifetime_ticket_value
   handle_asynchronously :calculate_lifetime_value
 
   attr_accessor :skip_sync_to_mailchimp, :skip_commit
-  attr_accessible :type, :email, :salutation, :dummy, :title, :company_name,
-    :website, :twitter_handle, :linked_in_url, :facebook_url, :subtype,
-    :first_name, :middle_name, :last_name, :suffix, :birth_day, :birth_month, :birth_year
-  attr_accessible :address_attributes, :phones_attributes, :relationships_attributes
+  attr_accessible :type, :email, :salutation, :dummy, :title, :company_name, :website, :twitter_handle, :linked_in_url, :facebook_url, :subtype, :address_attributes, :phones_attributes, :first_name, :middle_name, :last_name, :suffix
 
-  attr_accessible :subscribed_lists, :do_not_email, :do_not_call, :skip_sync_to_mailchimp
+  attr_accessible :subscribed_lists, :do_not_email, :skip_sync_to_mailchimp
   attr_accessible :organization_id
-
+  
   acts_as_taggable
 
-  belongs_to  :household
   belongs_to  :organization
   belongs_to  :import
   has_many    :actions
@@ -33,39 +26,10 @@ class Person < ActiveRecord::Base
   has_one     :address, :validate => false
   has_one     :member
   has_many    :memberships, :through => :member
-  has_many    :passes
-
-  has_many    :relationships, :foreign_key => :person_id, :class_name => 'Relationship'
-
-  def self.individuals
-    where(:type => 'Individual')
-  end
 
-  def self.companies
-    where(:type => 'Company')
-  end
-
-  #
-  # ACHTUNG! This where clause is qualified to people so that it playes nicely in advanced search
-  # as address also has a household_id column. If you are doing something un-orthodox and have
-  # a query which does alias the people table to people, this scope will not work
-  #
-  def self.in_household
-    where('people.household_id is not null')
-  end
-
-  def self.not_in_household
-    where('people.household_id is null')
-  end
-
-  def relationships_of_relation(relation)
-    relationships.joins(:relation).where(:relations => {:description => relation})
-  end
-
-  accepts_nested_attributes_for :relationships, :allow_destroy => true
   accepts_nested_attributes_for :address, :allow_destroy => false
   accepts_nested_attributes_for :phones, :reject_if => lambda { |p| p[:number].blank? }, :allow_destroy => true
-
+  
   default_scope where(:deleted_at => nil)
   before_save :check_do_not_email
   after_validation :validate_naming_details
@@ -73,18 +37,13 @@ class Person < ActiveRecord::Base
   after_update :sync_update_to_mailchimp, :except => :create
   serialize :subscribed_lists, Array
   validates_presence_of :organization_id, :type, :subtype
-  validates_numericality_of :birth_day, :birth_month, :birth_year, :allow_nil => true
-  validates_inclusion_of :birth_day, :in => 1..31, :allow_nil => true
-  validates_inclusion_of :birth_month, :in => 1..12, :allow_nil => true
-  validates_inclusion_of :birth_year, :in => 1900..DateTime.now.year, :allow_nil => true
 
   validates :email, :uniqueness => { :scope => [:organization_id, :deleted_at], :message => " %{value} has already been taken." }, :allow_blank => true
-  validate :birth_month_and_day
-
+  
   def dupe_code
     "#{first_name} | #{last_name} | #{email}"
   end
-
+  
   def self.find_dupes_in(organization)
     hash = {}
     Person.where(:organization_id => organization.id)
@@ -109,7 +68,7 @@ class Person < ActiveRecord::Base
       ""
     end
   end
-
+  
   #
   # An array of has_many associations that should be merged when a person record is merged with another
   # When an has_many association is added, it must be added here if the association is to be merged
@@ -117,13 +76,13 @@ class Person < ActiveRecord::Base
   # Tickets are a special case
   #
   def self.mergables
-    [:actions, :phones, :notes, :orders, :memberships, :passes]
+    [:actions, :phones, :notes, :orders, :memberships]
   end
-
+  
   def has_something?
     !has_nothing?
   end
-
+  
   def has_nothing?
     actions.empty? && phones.empty? && notes.empty? && orders.empty? && tickets.empty? && address.nil? && import_id.nil?
   end
@@ -150,15 +109,15 @@ class Person < ActiveRecord::Base
     text :address do
       address.to_s unless address.nil?
     end
-
+    
     text :tags do
       taggings.map{ |tagging| tagging.tag.name }
     end
-
+    
     text :notes do
       notes.map{ |note| note.text }.join(" ")
     end
-
+    
     string :first_name, :last_name, :email, :company_name, :title
     string :organization_id do
       organization.id
@@ -200,11 +159,6 @@ class Person < ActiveRecord::Base
     linked_in_url
     tags { |tags| tags.join("|") }
     do_not_email
-    do_not_call
-    household :name => 'Household Name'
-    birth_month
-    birth_day
-    birth_year
   end
 
   def self.find_by_import(import)
@@ -214,7 +168,7 @@ class Person < ActiveRecord::Base
   def self.recent(organization, limit = 10)
     Person.where(:organization_id => organization).order('updated_at DESC').limit(limit)
   end
-
+  
   def self.merge(winner, loser)
     unless winner.organization == loser.organization
       raise "Trying to merge two people [#{winner.id}] [#{loser.id}] from different organizations [#{winner.organization.id}] [#{winner.organization.id}]"
@@ -223,35 +177,27 @@ class Person < ActiveRecord::Base
     unless winner.type == loser.type
       raise "Trying to merge two people [#{winner.id}] [#{loser.id}] with different types [#{winner.type}] [#{loser.type}]"
     end
-
+    
     mergables.each do |mergable|
       loser.send(mergable).each do |m|
         m.person = winner
         m.save!
       end
     end
-
+    
     loser.tickets.each do |ticket|
       ticket.update_column(:buyer_id, winner.id)
     end
-
+    
     loser.tags.each do |t|
       winner.tag_list << t.name unless winner.tag_list.include? t.name
     end
 
-    loser.relationships.each do |r|
-      unless Relationship.where(:person_id => winner.id, :relation_id => r.relation.id, :other_id => r.other.id).first
-        winner.relationships << r
-      end
-    end
-
     winner.lifetime_value += loser.lifetime_value
     winner.lifetime_donations += loser.lifetime_donations
     winner.lifetime_ticket_value += loser.lifetime_ticket_value
-    winner.lifetime_memberships += loser.lifetime_memberships
 
     winner.do_not_email = true if loser.do_not_email?
-    winner.do_not_call = true if loser.do_not_call?
     new_lists = loser.subscribed_lists - winner.subscribed_lists
     winner.subscribed_lists = winner.subscribed_lists.concat(loser.subscribed_lists).uniq
     winner.save!
@@ -290,7 +236,7 @@ class Person < ActiveRecord::Base
 
     if self.address.blank?
       self.address.try(:destroy)
-      self.address = absorbee.address
+      self.address = absorbee.address 
     end
 
     absorbee.phones.each do |phone|
@@ -299,9 +245,9 @@ class Person < ActiveRecord::Base
 
     self
   end
-
+  
   def self.find_by_email_and_organization(email, organization)
-    return nil if email.blank?
+    return nil if email.blank? 
     find(:first, :conditions => { :email => email, :organization_id => organization.id })
   end
 
@@ -334,28 +280,25 @@ class Person < ActiveRecord::Base
   def unstarred_actions
     Action.where({ :person_id => id }).order('occurred_at desc').select{|a| a.unstarred?}
   end
-
+  
   def self.first_or_create(attributes=nil, options ={}, &block)
-    Rails.logger.debug("Person.first_or_create #{attributes.inspect}")
     attributes[:organization_id] ||= attributes[:organization].try(:id)
     raise(ArgumentError, "You must include an organization when searching for people") if attributes[:organization_id].blank?
-
+    
     attributes.delete(:organization)
-    return Person.where(:id => attributes[:id]).where(:organization_id => attributes[:organization_id]).first if attributes[:id].present?
     return Person.create(attributes, options, &block)                                  if attributes[:email].blank?
-
-    Person.where(:email => attributes[:email]).where(:organization_id => attributes[:organization_id]).first || Person.create(attributes, options, &block)
+    
+    Person.where(:email => attributes[:email]).where(:organization_id => attributes[:organization_id]).first || Person.create(attributes, options, &block) 
   end
-
+  
   def self.first_or_initialize(attributes=nil, options ={}, &block)
     attributes[:organization_id] ||= attributes[:organization].try(:id)
     raise(ArgumentError, "You must include an organization when searching for people") if attributes[:organization_id].blank?
-
+    
     attributes.delete(:organization)
-    return Person.where(:id => attributes[:id]).where(:organization_id => attributes[:organization_id]).first if attributes[:id].present?
     return Person.new(attributes, options, &block)                                     if attributes[:email].blank?
-
-    Person.where(:email => attributes[:email]).where(:organization_id => attributes[:organization_id]).first || Person.new(attributes, options, &block)
+    
+    Person.where(:email => attributes[:email]).where(:organization_id => attributes[:organization_id]).first || Person.new(attributes, options, &block) 
   end
 
   #
@@ -364,7 +307,7 @@ class Person < ActiveRecord::Base
   #
   def self.find_or_create(customer, organization)
     warn "[DEPRECATION] find_or_create will be removed in a future release. Please use first_or_create"
-
+    
     #TODO: Yuk
     if (customer.respond_to? :person_id) && (!customer.person_id.nil?)
       return Person.find(customer.person_id)
@@ -372,9 +315,9 @@ class Person < ActiveRecord::Base
       person = Person.where(:id => customer.id).where(:organization_id => organization.id).first
       return person if person
     end
-
+    
     person = Person.find_by_email_and_organization(customer.email, organization)
-
+      
     if person.nil?
       params = {
         :first_name      => customer.first_name,
@@ -387,25 +330,10 @@ class Person < ActiveRecord::Base
     person
   end
 
-  def update_name(first_name, last_name)
-    return if (self.first_name == first_name) && (self.last_name == last_name)
-
-    ActiveRecord::Base.transaction do
-      str = "Name changed from checkout."
-      unless (self.first_name.blank? && self.last_name.blank?)
-        str += " Old name was #{self.first_name} #{self.last_name}."
-      end
-      new_note(str, Time.now, nil, self.organization.id)
-      self.first_name = first_name.try(:capitalize)
-      self.last_name  = last_name.try(:capitalize)
-      self.save
-    end
-  end
-
   # Needs a serious refactor
   def update_address(new_address, time_zone, user = nil, updated_by = nil)
     unless new_address.nil?
-      new_address = Address.unhash(new_address)
+      new_address = Address.unhash(new_address) 
       new_address.person = self
       @address = Address.find_or_create(id)
       if !@address.update_with_note(self, user, new_address, time_zone, updated_by)
@@ -430,23 +358,13 @@ class Person < ActiveRecord::Base
       phones.create(:number => new_phone, :kind => "Other")
     end
   end
-
-  def previous_changes_sentence
-    if self.previous_changes.present?
-      str = ""
-      self.previous_changes.except(:updated_at).each do |field,changes|
-        str = str + "#{field.capitalize} changed from '#{changes[0]}' to '#{changes[1]}'. "
-      end
-      str
-    end
-  end
-
+  
   def new_note(text, occurred_at, user, organization_id)
-    note = notes.build({
+    note = notes.create({
       :text => text,
       :occurred_at => Time.now
-    })
-    note.user_id = user.id if user
+    })    
+    note.user_id = user.id
     note.organization_id = organization_id
     note.save
     note
@@ -457,10 +375,6 @@ class Person < ActiveRecord::Base
       new_note("#{user.email} changed do not email to #{do_not_email}",Time.now,user,organization.id)
     end
 
-    if previous_changes["do_not_call"]
-      new_note("#{user.email} changed do not call to #{do_not_call}",Time.now,user,organization.id)
-    end
-
     if previous_changes["subscribed_lists"]
       mailchimp_kit.attached_lists.each do |list|
         old_lists = previous_changes["subscribed_lists"][0]
@@ -500,14 +414,6 @@ class Person < ActiveRecord::Base
     first_name.present? || last_name.present? || email.present? || company_name.present?
   end
 
-  def send_pass_summary_email(passes)
-    PassMailer.pass_info_for(self, self.organization.email,passes).deliver
-  end
-
-  def any_current_passes?
-    passes.not_expired.any?
-  end
-
   private
     def sync_update_to_mailchimp
       return if skip_sync_to_mailchimp
@@ -527,14 +433,4 @@ class Person < ActiveRecord::Base
     def check_do_not_email
       self.subscribed_lists = [] if do_not_email
     end
-    
-    def birth_month_and_day
-      if self.birth_month.present? && self.birth_day.blank?
-        errors.add(:birth_day, "cannot be blank.")
-      end
-      
-      if self.birth_month.blank? && self.birth_day.present?
-        errors.add(:birth_month, "cannot be blank.")
-      end
-    end
 end