artfully_ose 1.0.0.rc4 → 1.1.0.rc1

data/app/models/parsed_row.rb

@@ -0,0 +1,167 @@
+class ParsedRow
+  
+  attr_accessor :row
+
+  #Fields which require special parsing such as dollar amounts
+  EXCEPTIONS = [:amount, :nongift_amount, :deductible_amount]
+
+  SHARED_FIELDS = {
+    :first            => [ "First name", "First" ],
+    :last             => [ "Last name", "Last" ],
+    :email            => [ "Email", "Email address" ]
+  }
+
+  PEOPLE_FIELDS = SHARED_FIELDS.merge( {
+    :salutation       => [ "Salutation" ],     
+    :title            => [ "Title" ],
+    :company          => [ "Company name", "Company" ],
+    :address1         => [ "Address 1", "Address1" ],
+    :address2         => [ "Address 2", "Address2" ],
+    :city             => [ "City" ],
+    :state            => [ "State" ],
+    :zip              => [ "Zip", "Zip code" ],
+    :country          => [ "Country" ],
+    :phone1_type      => [ "Phone1 type", "Phone 1 type" ],
+    :phone1_number    => [ "Phone1 number", "Phone 1", "Phone 1 number", "Phone1" ],
+    :phone2_type      => [ "Phone2 type", "Phone 2 type" ],
+    :phone2_number    => [ "Phone2 number", "Phone 2", "Phone 2 number", "Phone2" ],
+    :phone3_type      => [ "Phone3 type", "Phone 3 type" ],
+    :phone3_number    => [ "Phone3 number", "Phone 3", "Phone 3 number", "Phone3" ],
+    :website          => [ "Website" ],
+    :twitter_username => [ "Twitter handle", "Twitter", "Twitter username" ],
+    :facebook_page    => [ "Facebook url", "Facebook", "Facebook address", "Facebook page" ],
+    :linkedin_page    => [ "Linked in url", "LinkedIn url", "LinkedIn", "LinkedIn address", "LinkedIn page" ],
+    :tags             => [ "Tags" ],
+    :do_not_email     => [ "Do Not Email" ],
+    :person_type      => [ "Person Type" ]   
+  })
+  
+  EVENT_FIELDS = SHARED_FIELDS.merge( {
+    :event_name       => [ "Event", "Event Name" ],
+    :venue_name       => [ "Venue", "Venue Name" ],
+    :show_date        => [ "Show Date", "Show" ],
+    :amount           => [ "Amount", "Dollar Amount" ],
+    :payment_method   => [ "Payment Method" ],
+    :order_date       => [ "Order Date", "Date" ]
+  })
+  
+  DONATION_FIELDS = SHARED_FIELDS.merge( {
+    :payment_method   => [ "Payment Method" ],
+    :donation_date    => [ "Date", "Order Date" ],
+    :donation_type    => [ "Donation Type", "Type" ],
+    :amount           => [ "Amount" ],
+    :deductible_amount=> [ "Deductible Amount" ],
+    
+    #Internally it is called nongift_amount but the rest of the world says non-deductible
+    :nongift_amount  => [ "Non-Deductible Amount", "Non Deductible Amount" ]
+    
+    #TODO: Total contribution sanity check
+  })
+  
+  FIELDS = PEOPLE_FIELDS.merge(EVENT_FIELDS).merge(DONATION_FIELDS)
+
+  # Enumerated columns default to the last value if the data value is not valid.
+  #
+  # With the way the current code is using instance_variable_get, columns that use an enumeration
+  # cannot accept multiple column names.  We can only have one column name map to person_type
+  ENUMERATIONS = {
+    :person_type => [ "Individual", "Corporation", "Foundation", "Government", "Other" ]
+  }
+
+  def self.parse(headers, row)
+    ParsedRow.new(headers, row)
+  end
+  
+  def initialize(headers, row)
+    @headers = headers
+    @row = row
+
+    FIELDS.each do |field, columns|
+      columns.each do |column|
+        load_value field, column
+      end
+    end
+  end
+
+  def load_value(field, column)
+    index = @headers.index { |h| h.to_s.downcase.strip == column.downcase }
+    value = @row[index] if index
+    exist = self.instance_variable_get("@#{field}")
+
+    if exist.blank?
+      value = check_enumeration(field, value)
+
+      self.instance_variable_set("@#{field}", value)
+      
+      #skip amount because we have to parse it
+      unless EXCEPTIONS.include? field
+        self.class.class_eval { attr_reader field }
+      end
+    end
+  end
+
+  def tags_list
+    @tags.to_s.strip.gsub(/\s+/, "-").split(/[,|]+/)
+  end
+
+  def check_enumeration(field, value)
+    if enum = ENUMERATIONS[field]      
+      if index = enum.map(&:downcase).index(value.to_s.downcase)
+        enum[index]
+      else
+        enum.last
+      end
+    else
+      value
+    end
+  end
+  
+  def nongift_amount
+    ((@nongift_amount.to_f || 0) * 100).to_i
+  end
+  
+  def unparsed_nongift_amount
+    @nongift_amount
+  end
+  
+  def amount
+    ((@amount.to_f || 0) * 100).to_i
+  end
+  
+  def unparsed_amount
+    @amount
+  end
+  
+  def deductible_amount
+    ((@deductible_amount.to_f || 0) * 100).to_i
+  end
+  
+  def unparsed_deductible_amount
+    @deductible_amount
+  end
+  
+  def importing_event?
+    !self.event_name.blank?
+  end
+  
+  def preview(field_name)
+    field_name.to_s.ends_with?("amount") ? self.send("unparsed_#{field_name}") : self.send(field_name)
+  end
+  
+  def person_attributes
+      {
+        :email           => self.email,
+        :salutation      => self.salutation,
+        :title      => self.title,
+        :first_name      => self.first,
+        :last_name       => self.last,
+        :company_name    => self.company,
+        :website         => self.website,
+        :twitter_handle  => self.twitter_username,
+        :facebook_url    => self.facebook_page,
+        :linked_in_url   => self.linkedin_page,
+        :person_type     => self.person_type
+      }
+  end
+
+end

data/app/models/payments/comp_payment.rb

@@ -1,4 +1,4 @@
-#3This class is used to encapsulate a comp made through a payment interface (the box office)  
+# This class is used to encapsulate a comp made through a payment interface (the box office)  
 # Comping from producer screens doesn't use this class
 class CompPayment < Payment
   payment_method :comp
@@ -16,6 +16,15 @@ class CompPayment < Payment
     false
   end
 
+  def refundable?
+    false
+  end
+
+  def refund
+    self.errors.add(:base, "Comp orders cannot be refunded.  Please return the tickets to inventory instead.")
+    false
+  end
+
   def requires_settlement?
     false
   end

data/app/models/payments/credit_card_payment.rb

@@ -1,5 +1,5 @@
 class CreditCardPayment < ::Payment
-  payment_method [:credit_card, :credit_card_swipe, :credit_card_manual]
+  payment_method [:credit_card, :credit_card_swipe, :credit_card_manual, :cc, :credit]
   
   #ActiveMerchant::Billing::CreditCard
   attr_accessor :credit_card 
@@ -14,8 +14,12 @@ class CreditCardPayment < ::Payment
     lambda { |item| item.realized_price * 0.035 }
   end
   
+  def payment_phone_number
+    self.customer.phones.first.try(:number)
+  end
+  
   #
-  # We may be able to get some milage out of a reop called active_attr: https://github.com/cgriego/active_attr
+  # 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| 
@@ -32,6 +36,7 @@ class CreditCardPayment < ::Payment
       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],
@@ -52,25 +57,73 @@ class CreditCardPayment < ::Payment
   def requires_authorization?
     amount > 0
   end
+
+  def requires_settlement?
+    true
+  end
+
+  #
+  # refund_amount: The total amount of money to be sent to the patron
+  # transaction_id: The transaction_id of the original transaction
+  # options:
+  #   :service_fee: The service fees being refunded.  This is for record keeping *only*  It WILL NOT be added to refund_amount
+  #
+  def refund(refund_amount, transaction_id, options = {})
+    return true if (refund_amount <= 0)
+    response = gateway.refund(refund_amount, transaction_id)
+    record_gateway_transaction((options[:service_fee] * -1), (refund_amount * -1), response)
+    self.transaction_id = response.authorization
+    self.errors.add(:base, response.message) unless response.message.blank?
+    response.success?
+  end
   
   #purchase submits for auth and passes a flag to merchant to settle immediately
   def purchase(options={})
-    ::Rails.logger.debug("Sending purchase request to Braintree")
-    response = gateway.purchase(self.amount, credit_card, options)
-    ::Rails.logger.debug("Received response: #{response.message}")
-    ::Rails.logger.debug(response.inspect)
+    response = gateway.purchase(self.amount, credit_card, options.except(:service_fee))
+    record_gateway_transaction(options[:service_fee], self.amount, response)
     self.transaction_id = response.authorization
-    response
+    self.errors.add(:base, BRAINTREE_REJECT_MESSAGE_MAPPING[response.message]) unless response.message.blank?
+    response.success?
+    
+    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
   end
   
   def authorize(options={})
     response = gateway.authorize(self.amount, credit_card, options)
     self.transaction_id = response.authorization
-    response
+    response.authorization
   end
   
-  def capture(response, options={})
-    gateway.capture(self.amount, response.authorization, options)
+  def capture(authorization, options={})
+    gateway.capture(self.amount, authorization, options)
   end
   alias :settle :capture
+
+  #
+  # This can't be delayed_job'd because DJ can't deserialize ARs that haven't been persisted
+  #
+  def record_gateway_transaction(service_fee, amount, response)
+    begin 
+      attrs = {}
+      attrs[:transaction_id] = response.authorization
+      attrs[:success]        = response.success?
+      attrs[:service_fee]    = service_fee
+      attrs[:amount]         = amount
+      attrs[:message]        = response.message
+      attrs[:response]       = response
+      @gateway_transaction = GatewayTransaction.create(attrs)
+    rescue Exception => e
+      ::Exceptional.context(:gateway_transaction => @gateway_transaction)
+      ::Exceptional.handle(e, "Failed to persist Gateway Transaction")
+    end
+  end
 end

data/app/models/payments/payment.rb

@@ -1,3 +1,7 @@
+#
+# Payment subclasses should not involve Artful.ly classes in the internals of ActiveMerchant.  
+# Errors should be commincated to callers with the errors Array
+#
 class Payment 
   include ActiveModel::Validations
   
@@ -30,6 +34,10 @@ class Payment
       def payment_method
         "#{names[0].to_s.gsub('_',' ').capitalize}"
       end
+      
+      def self.payment_method
+        "#{names[0].to_s.gsub('_',' ').capitalize}"
+      end
     EOS
   end
 
@@ -37,6 +45,7 @@ class Payment
   # Call this method to create sub-classes of Payment.  params will be passed through to the child class
   #
   def self.create(type, params = {})
+    type = type.parameterize.underscore.to_sym if type.is_a? String
     c = @@payment_methods[type]
     if c 
       c.new(params)
@@ -50,10 +59,29 @@ class Payment
   #
   def purchase(options = {})
   end
+
+  #
+  # Likewise with payments that need to refund
+  #
+  def refundable?
+    true
+  end
+
+  def refund(refund_amount, transaction_id, options = {})
+    true
+  end
   
   def requires_authorization?
     false
   end
+
+  def requires_settlement?
+    false
+  end
+  
+  def payment_phone_number
+    nil
+  end
   
   def reduce_amount_by(amount_in_cents)
     self.amount= self.amount - amount_in_cents

data/app/models/person.rb

@@ -1,11 +1,16 @@
 class Person < ActiveRecord::Base
   include Valuation::LifetimeValue
+  include Valuation::LifetimeDonations
 
-  attr_accessible :type, :email, :first_name, :last_name, :company_name, :website, :twitter_handle, :linked_in_url, :facebook_url, :person_type
+  attr_accessor :skip_sync_to_mailchimp, :skip_commit
+  attr_accessible :type, :email, :salutation, :title, :dummy, :first_name, :last_name, :company_name, :website, :twitter_handle, :linked_in_url, :facebook_url, :person_type
+  attr_accessible :subscribed_lists, :do_not_email, :skip_sync_to_mailchimp
+  attr_accessible :organization_id
   
   acts_as_taggable
 
   belongs_to  :organization
+  belongs_to  :import
   has_many    :actions
   has_many    :phones
   has_many    :notes
@@ -14,15 +19,20 @@ class Person < ActiveRecord::Base
   has_one     :address
   
   default_scope where(:deleted_at => nil)
+  before_save :check_do_not_email
+  after_update :sync_update_to_mailchimp, :except => :create
+  serialize :subscribed_lists, Array
+  validates_presence_of :organization_id
+  validates_presence_of :person_info
 
-  attr_accessible :first_name, :last_name, :email, :dummy, :organization_id
+  validates :email, :uniqueness => { :scope => [:organization_id, :deleted_at] }, :allow_blank => true
 
   def destroy!
     destroy
   end
 
   def destroy
-    update_attribute(:deleted_at, Time.now)
+    update_column(:deleted_at, Time.now)
   end
   
   def dupe_code
@@ -42,21 +52,6 @@ class Person < ActiveRecord::Base
     end
     hash
   end
-
-  #
-  # One off method.  Remove this when Libra's records are cleared up
-  #
-  def self.delete_dupes_in(organization)
-    Person.find_dupes_in(organization).each do |k,v|
-      if v.length > 100
-        puts "Deleting [#{v.length}] of: #{v.first.id} #{v.first.first_name} #{v.first.last_name}"
-        v.reject! {|p| p.has_something?}
-        Person.delete v
-      end
-    end
-    
-    nil
-  end
   
   #
   # An array of has_many associations that should be merged when a person record is merged with another
@@ -76,12 +71,6 @@ class Person < ActiveRecord::Base
     actions.empty? && phones.empty? && notes.empty? && orders.empty? && tickets.empty? && address.nil? && import_id.nil?
   end
 
-  validates_presence_of :organization_id
-  validates_presence_of :person_info
-
-  validates :email, :uniqueness => { :scope => [:organization_id, :deleted_at] }, :allow_blank => true
-  after_commit { Sunspot.commit }
-
   searchable do
     text :first_name, :last_name, :email
     text :address do
@@ -101,18 +90,14 @@ class Person < ActiveRecord::Base
       organization.id
     end
   end
-
-  def self.search_index(query, organization)
-    self.search do
-      fulltext query
-      with(:organization_id).equal_to(organization.id)
-    end.results
-  end
+  include Ext::DelayedIndexing
 
   comma do
     email
+    salutation
     first_name
     last_name
+    title
     company_name
     address("Address 1") { |address| address && address.address1 }
     address("Address 2") { |address| address && address.address2 }
@@ -132,6 +117,7 @@ class Person < ActiveRecord::Base
     linked_in_url
     tags { |tags| tags.join("|") }
     person_type
+    do_not_email
   end
 
   def self.find_by_import(import)
@@ -149,12 +135,13 @@ class Person < ActiveRecord::Base
     
     mergables.each do |mergable|
       loser.send(mergable).each do |m|
-        m.update_attribute(:person, winner)
+        m.person = winner
+        m.save!
       end
     end
     
     loser.tickets.each do |ticket|
-      ticket.update_attribute(:buyer, winner)
+      ticket.update_column(:buyer_id, winner.id)
     end
     
     loser.tags.each do |t|
@@ -162,14 +149,22 @@ class Person < ActiveRecord::Base
     end
 
     winner.lifetime_value += loser.lifetime_value
-    
+    winner.lifetime_donations += loser.lifetime_donations
+
+    winner.do_not_email = true if loser.do_not_email?
+    new_lists = loser.subscribed_lists - winner.subscribed_lists
+    winner.subscribed_lists = winner.subscribed_lists.concat(loser.subscribed_lists).uniq
     winner.save!
     loser.destroy!
+
+    mailchimp_kit = winner.organization.kits.mailchimp
+    MailchimpSyncJob.merged_person(mailchimp_kit, loser.email, winner.id, new_lists) if mailchimp_kit
+
     return winner
   end
   
   def self.find_by_email_and_organization(email, organization)
-    return nil if email.nil? 
+    return nil if email.blank? 
     find(:first, :conditions => { :email => email, :organization_id => organization.id })
   end
 
@@ -195,10 +190,6 @@ class Person < ActiveRecord::Base
     })
   end
 
-  def to_customer
-    AthenaCustomer.new(:person_id => id, :email => email, :first_name => first_name, :last_name => last_name)
-  end
-
   def starred_actions
     Action.where({ :person_id => id, :starred => true }).order(:occurred_at)
   end
@@ -206,14 +197,29 @@ class Person < ActiveRecord::Base
   def unstarred_actions
     Action.where({ :person_id => id }).order('occurred_at desc').select{|a| a.unstarred?}
   end
+  
+  #
+  # We're overriding this in order to excapsulate what is needed to
+  # find a unique person
+  #
+  # DO NOT CALL THIS METHOD WITH A BLANK EMAIL
+  #
+  def self.first_or_create(email, organization, attributes=nil, options ={}, &block)
+    Person.where(:email => email).where(:organization_id => organization.id).first_or_create(attributes, options, &block)
+  end
 
   #
   # You can pass any object as first param as long as it responds to
   # .first_name, .last_name, and .email
   #
   def self.find_or_create(customer, organization)
+    
+    #TODO: Yuk
     if (customer.respond_to? :person_id) && (!customer.person_id.nil?)
       return Person.find(customer.person_id)
+    elsif (customer.is_a? Person) && (!customer.id.nil?)
+      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)
@@ -223,7 +229,7 @@ class Person < ActiveRecord::Base
         :first_name      => customer.first_name,
         :last_name       => customer.last_name,
         :email           => customer.email,
-        :organization_id => organization.id # This doesn't account for multiple organizations per cart
+        :organization_id => organization.id
       }
       person = Person.create(params)
     end
@@ -246,15 +252,81 @@ class Person < ActiveRecord::Base
     true
   end
 
-  # The name of this method makes no sense
+  #
+  # Will add a phone number ot this record if the number doesn't already exist
+  #
   def add_phone_if_missing(new_phone)
     if (!new_phone.blank? and phones.where("number = ?", new_phone).empty?)
       phones.create(:number => new_phone, :kind => "Other")
     end
   end
+  
+  def new_note(text, occurred_at, user, organization_id)
+    note = notes.create({
+      :text => text,
+      :occurred_at => Time.now
+    })    
+    note.user_id = user.id
+    note.organization_id = organization_id
+    note.save
+    note
+  end
+
+  def create_subscribed_lists_notes!(user)
+    if previous_changes["do_not_email"]
+      new_note("#{user.email} changed do not email to #{do_not_email}",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]
+        if !old_lists.include?(list[:list_id]) && subscribed_lists.include?(list[:list_id])
+          new_note("#{user.email} changed subscription status of the MailChimp list #{list[:list_name]} to subscribed",Time.now,user,organization.id)
+        elsif old_lists.include?(list[:list_id]) && !subscribed_lists.include?(list[:list_id])
+          new_note("#{user.email} changed subscription status of the MailChimp list #{list[:list_name]} to unsubscribed",Time.now,user,organization.id)
+        end
+      end
+    end
+  end
+
+  def to_s
+    if first_name.present? && last_name.present?
+      "#{first_name} #{last_name}"
+    elsif first_name.present?
+      first_name.to_s
+    elsif last_name.present?
+      last_name.to_s
+    elsif email.present?
+      email.to_s
+    elsif id.present?
+      "No Name ##{id}"
+    else
+      "No Name"
+    end
+  end
+
+  #Bad name.  This will respond with true if there is something in first_name, last_name, or email.  False otherwise.
+  def person_info
+    !(first_name.blank? and last_name.blank? and email.blank?)
+  end
 
   private
-    def person_info
-      !(first_name.blank? and last_name.blank? and email.blank?)
+    def sync_update_to_mailchimp
+      return if skip_sync_to_mailchimp
+      return unless mailchimp_changes? && mailchimp_kit
+      job = MailchimpSyncJob.new(mailchimp_kit, :type => :person_update_to_mailchimp, :person_id => id, :person_changes => changes)
+      Delayed::Job.enqueue(job, :queue => "mailchimp") if !mailchimp_kit.cancelled?
+    end
+
+    def mailchimp_kit
+      @mailchimp_kit ||= organization.kits.detect { |kit| kit.is_a?(MailchimpKit) }
+    end
+
+    def mailchimp_changes?
+      ["first_name", "last_name", "email", "do_not_email", "subscribed_lists"].any? { |attr| changes.keys.include?(attr) }
+    end
+
+    def check_do_not_email
+      self.subscribed_lists = [] if do_not_email
     end
 end